From abab8b62d6f8a65e57d88460aa978e9d83a220e8 Mon Sep 17 00:00:00 2001 From: axenteoctavian Date: Thu, 4 Jan 2024 10:55:07 +0200 Subject: [PATCH 01/56] Sovereign node component refactor --- cmd/sovereignnode/sovereignNodeRunner.go | 43 +++++++++++---------- node/interface.go | 26 +++++++++++++ node/node.go | 12 ++++++ node/nodeFactory.go | 22 +++++++++++ node/nodeFactory_test.go | 24 ++++++++++++ node/nodeHelper.go | 8 ++-- node/nodeRunner.go | 49 +++++++++++++----------- node/sovereignNode.go | 28 ++++++++++++++ node/sovereignNodeFactory.go | 23 +++++++++++ node/sovereignNodeFactory_test.go | 24 ++++++++++++ 10 files changed, 213 insertions(+), 46 deletions(-) create mode 100644 node/nodeFactory.go create mode 100644 node/nodeFactory_test.go create mode 100644 node/sovereignNode.go create mode 100644 node/sovereignNodeFactory.go create mode 100644 node/sovereignNodeFactory_test.go diff --git a/cmd/sovereignnode/sovereignNodeRunner.go b/cmd/sovereignnode/sovereignNodeRunner.go index acfccfe76f4..f0cd11aa3ad 100644 --- a/cmd/sovereignnode/sovereignNodeRunner.go +++ b/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,9 +713,9 @@ 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) @@ -722,7 +723,7 @@ func (snr *sovereignNodeRunner) createApiFacade( 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...") diff --git a/node/interface.go b/node/interface.go index 23a706ed25a..19dbc4513d3 100644 --- a/node/interface.go +++ b/node/interface.go @@ -1,6 +1,9 @@ package node import ( + "github.com/multiversx/mx-chain-go/debug" + "github.com/multiversx/mx-chain-go/facade" + mainFactory "github.com/multiversx/mx-chain-go/factory" "io" "time" @@ -62,3 +65,26 @@ type accountHandlerWithDataTrieMigrationStatus interface { vmcommon.AccountHandler IsDataTrieMigrated() (bool, error) } + +type NodeFactory interface { + CreateNewNode(opts ...Option) (NodeHandler, error) + IsInterfaceNil() bool +} + +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 +} diff --git a/node/node.go b/node/node.go index 314488cbe29..a6730f4ef81 100644 --- a/node/node.go +++ b/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 diff --git a/node/nodeFactory.go b/node/nodeFactory.go new file mode 100644 index 00000000000..bed46a03def --- /dev/null +++ b/node/nodeFactory.go @@ -0,0 +1,22 @@ +package node + +type nodeFactory struct { +} + +func NewNodeFactory() *nodeFactory { + return &nodeFactory{} +} + +func (nf *nodeFactory) CreateNewNode(opts ...Option) (NodeHandler, error) { + n, err := NewNode(opts...) + + if err != nil { + return nil, err + } + + return n, nil +} + +func (nf *nodeFactory) IsInterfaceNil() bool { + return nf == nil +} diff --git a/node/nodeFactory_test.go b/node/nodeFactory_test.go new file mode 100644 index 00000000000..cf70bd059d5 --- /dev/null +++ b/node/nodeFactory_test.go @@ -0,0 +1,24 @@ +package node + +import ( + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" + "testing" +) + +func TestNewNodeFactory(t *testing.T) { + t.Parallel() + + nodeFactory := NewNodeFactory() + require.False(t, nodeFactory.IsInterfaceNil()) +} + +func TestNodeFactory_CreateNewNode(t *testing.T) { + t.Parallel() + + nodeFactory := NewNodeFactory() + + n, err := nodeFactory.CreateNewNode() + assert.Nil(t, err) + assert.NotNil(t, n) +} diff --git a/node/nodeHelper.go b/node/nodeHelper.go index b51a2146d87..ed75f3bbf35 100644 --- a/node/nodeHelper.go +++ b/node/nodeHelper.go @@ -55,8 +55,10 @@ func CreateNode( consensusComponents factory.ConsensusComponentsHandler, bootstrapRoundIndex uint64, isInImportMode bool, + factoryNode NodeFactory, extraOptions ...Option, -) (*Node, error) { + +) (NodeHandler, error) { prepareOpenTopics(networkComponents.InputAntiFloodHandler(), processComponents.ShardCoordinator()) peerDenialEvaluator, err := createAndAttachPeerDenialEvaluators(networkComponents, processComponents) @@ -71,7 +73,7 @@ func CreateNode( return nil, err } - var nd *Node + var nd NodeHandler options := []Option{ WithStatusCoreComponents(statusCoreComponents), WithCoreComponents(coreComponents), @@ -101,7 +103,7 @@ func CreateNode( } options = append(options, extraOptions...) - nd, err = NewNode(options...) + nd, err = factoryNode.CreateNewNode(options...) if err != nil { return nil, errors.New("error creating node: " + err.Error()) } diff --git a/node/nodeRunner.go b/node/nodeRunner.go index 7c4d160e340..d831e965e23 100644 --- a/node/nodeRunner.go +++ b/node/nodeRunner.go @@ -485,13 +485,12 @@ func (nr *nodeRunner) executeOneComponentCreationCycle( managedProcessComponents, managedStatusCoreComponents, ) - if err != nil { return true, err } log.Debug("creating node structure") - currentNode, err := CreateNode( + nodeHandler, err := CreateNode( configs.GeneralConfig, managedStatusCoreComponents, managedBootstrapComponents, @@ -506,6 +505,7 @@ func (nr *nodeRunner) executeOneComponentCreationCycle( managedConsensusComponents, flagsConfig.BootstrapRoundIndex, configs.ImportDbConfig.IsImportDBMode, + NewNodeFactory(), ) if err != nil { return true, err @@ -525,7 +525,7 @@ func (nr *nodeRunner) executeOneComponentCreationCycle( allowExternalVMQueriesChan := make(chan struct{}) log.Debug("updating the API service after creating the node facade") - facadeInstance, err := nr.createApiFacade(currentNode, webServerHandler, gasScheduleNotifier, allowExternalVMQueriesChan) + facadeInstance, err := nr.createApiFacade(nodeHandler, webServerHandler, gasScheduleNotifier, allowExternalVMQueriesChan) if err != nil { return true, err } @@ -553,7 +553,7 @@ func (nr *nodeRunner) executeOneComponentCreationCycle( healthService, facadeInstance, webServerHandler, - currentNode, + nodeHandler, goRoutinesNumberStart, ) @@ -696,7 +696,7 @@ func getBaseAccountSyncerArgs( } func (nr *nodeRunner) createApiFacade( - currentNode *Node, + nodeHandler NodeHandler, upgradableHttpServer shared.UpgradeableHttpServerHandler, gasScheduleNotifier common.GasScheduleNotifierAPI, allowVMQueriesChan chan struct{}, @@ -707,17 +707,17 @@ func (nr *nodeRunner) createApiFacade( apiResolverArgs := &apiComp.ApiResolverArgs{ Configs: configs, - CoreComponents: currentNode.coreComponents, - DataComponents: currentNode.dataComponents, - StateComponents: currentNode.stateComponents, - BootstrapComponents: currentNode.bootstrapComponents, - CryptoComponents: currentNode.cryptoComponents, - ProcessComponents: currentNode.processComponents, - StatusCoreComponents: currentNode.statusCoreComponents, + 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.consensusComponents.Bootstrapper(), + Bootstrapper: nodeHandler.GetConsensusComponents().Bootstrapper(), AllowVMQueriesChan: allowVMQueriesChan, - StatusComponents: currentNode.statusComponents, + StatusComponents: nodeHandler.GetStatusComponents(), ProcessingMode: common.GetNodeProcessingMode(nr.configs.ImportDbConfig), ChainRunType: common.ChainRunTypeRegular, } @@ -732,7 +732,7 @@ func (nr *nodeRunner) createApiFacade( flagsConfig := configs.FlagsConfig argNodeFacade := facade.ArgNodeFacade{ - Node: currentNode, + Node: nodeHandler, ApiResolver: apiResolver, RestAPIServerDebugMode: flagsConfig.EnableRestAPIServerDebugMode, WsAntifloodConfig: configs.GeneralConfig.WebServerAntiflood, @@ -741,9 +741,9 @@ func (nr *nodeRunner) createApiFacade( PprofEnabled: flagsConfig.EnablePprof, }, ApiRoutesConfig: *configs.ApiRoutesConfig, - AccountsState: currentNode.stateComponents.AccountsAdapter(), - PeerState: currentNode.stateComponents.PeerAccounts(), - Blockchain: currentNode.dataComponents.Blockchain(), + AccountsState: nodeHandler.GetStateComponents().AccountsAdapter(), + PeerState: nodeHandler.GetStateComponents().PeerAccounts(), + Blockchain: nodeHandler.GetDataComponents().Blockchain(), } ef, err := facade.NewNodeFacade(argNodeFacade) @@ -751,7 +751,7 @@ func (nr *nodeRunner) createApiFacade( return nil, fmt.Errorf("%w while creating NodeFacade", err) } - ef.SetSyncer(currentNode.coreComponents.SyncTimer()) + ef.SetSyncer(nodeHandler.GetCoreComponents().SyncTimer()) err = upgradableHttpServer.UpdateFacade(ef) if err != nil { @@ -949,13 +949,18 @@ func (nr *nodeRunner) CreateManagedHeartbeatV2Components( return managedHeartbeatV2Components, nil } +//func (nr *nodeRunner) CreateNodeFactory() (NodeFactory, error) { +// nf := NewNodeFactory() +// return nf, nil +//} + func waitForSignal( sigs chan os.Signal, chanStopNodeProcess chan endProcess.ArgEndProcess, healthService closing.Closer, facade closing.Closer, httpServer shared.UpgradeableHttpServerHandler, - currentNode *Node, + nodeHandler NodeHandler, goRoutinesNumberStart int, ) nextOperationForNode { var sig endProcess.ArgEndProcess @@ -979,7 +984,7 @@ func waitForSignal( chanCloseComponents := make(chan struct{}) go func() { - closeAllComponents(healthService, facade, httpServer, currentNode, chanCloseComponents) + closeAllComponents(healthService, facade, httpServer, nodeHandler, chanCloseComponents) }() select { @@ -1563,7 +1568,7 @@ func closeAllComponents( healthService io.Closer, facade mainFactory.Closer, httpServer shared.UpgradeableHttpServerHandler, - node *Node, + node NodeHandler, chanCloseComponents chan struct{}, ) { log.Debug("closing health service...") diff --git a/node/sovereignNode.go b/node/sovereignNode.go new file mode 100644 index 00000000000..a2c4e8d42ab --- /dev/null +++ b/node/sovereignNode.go @@ -0,0 +1,28 @@ +package node + +import ( + "context" + "github.com/multiversx/mx-chain-core-go/data/api" +) + +type SovereignNode struct { + *Node +} + +func NewSovereignNode(node *Node) *SovereignNode { + return &SovereignNode{ + node, + } +} + +func (sn *SovereignNode) GetAllIssuedESDTs(tokenType string, ctx context.Context) ([]string, error) { + return sn.baseGetAllIssuedESDTs(tokenType, ctx) +} + +func (sn *SovereignNode) baseGetTokensIDsWithFilter( + f filter, + options api.AccountQueryOptions, + ctx context.Context, +) ([]string, api.BlockInfo, error) { + return sn.baseGetTokensIDsWithFilter(f, options, ctx) +} diff --git a/node/sovereignNodeFactory.go b/node/sovereignNodeFactory.go new file mode 100644 index 00000000000..60c60f43dbb --- /dev/null +++ b/node/sovereignNodeFactory.go @@ -0,0 +1,23 @@ +package node + +type sovereignNodeFactory struct { +} + +func NewSovereignNodeFactory() *sovereignNodeFactory { + return &sovereignNodeFactory{} +} + +func (snf *sovereignNodeFactory) CreateNewNode(opts ...Option) (NodeHandler, error) { + nd, err := NewNode(opts...) + + if err != nil { + return nil, err + } + + snd := NewSovereignNode(nd) + return snd, nil +} + +func (snf *sovereignNodeFactory) IsInterfaceNil() bool { + return snf == nil +} diff --git a/node/sovereignNodeFactory_test.go b/node/sovereignNodeFactory_test.go new file mode 100644 index 00000000000..c7621b6b0b2 --- /dev/null +++ b/node/sovereignNodeFactory_test.go @@ -0,0 +1,24 @@ +package node + +import ( + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" + "testing" +) + +func TestNewSovereignNodeFactory(t *testing.T) { + t.Parallel() + + sovereignNodeFactory := NewSovereignNodeFactory() + require.False(t, sovereignNodeFactory.IsInterfaceNil()) +} + +func TestSovereignNodeFactory_CreateNewNode(t *testing.T) { + t.Parallel() + + sovereignNodeFactory := NewSovereignNodeFactory() + + sn, err := sovereignNodeFactory.CreateNewNode() + assert.Nil(t, err) + assert.NotNil(t, sn) +} From ca15d7181f32ff7fd7f27243927259ee961f947e Mon Sep 17 00:00:00 2001 From: axenteoctavian Date: Thu, 4 Jan 2024 11:10:17 +0200 Subject: [PATCH 02/56] fix override method in SovereignNode --- node/sovereignNode.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/node/sovereignNode.go b/node/sovereignNode.go index a2c4e8d42ab..1fe8dc73e96 100644 --- a/node/sovereignNode.go +++ b/node/sovereignNode.go @@ -19,7 +19,7 @@ func (sn *SovereignNode) GetAllIssuedESDTs(tokenType string, ctx context.Context return sn.baseGetAllIssuedESDTs(tokenType, ctx) } -func (sn *SovereignNode) baseGetTokensIDsWithFilter( +func (sn *SovereignNode) getTokensIDsWithFilter( f filter, options api.AccountQueryOptions, ctx context.Context, From 2849ee4551e042af4bf23574330bb030c10ee187 Mon Sep 17 00:00:00 2001 From: axenteoctavian Date: Thu, 4 Jan 2024 14:42:50 +0200 Subject: [PATCH 03/56] some fixes and unit tests added --- node/errors.go | 3 + node/interface.go | 2 + node/nodeFactory_test.go | 14 +- node/sovereignNode.go | 71 +++++- node/sovereignNodeFactory.go | 5 +- node/sovereignNodeFactory_test.go | 17 +- node/sovereignNode_test.go | 354 ++++++++++++++++++++++++++++++ 7 files changed, 442 insertions(+), 24 deletions(-) create mode 100644 node/sovereignNode_test.go diff --git a/node/errors.go b/node/errors.go index 69e0d5c0d69..4e75430e15d 100644 --- a/node/errors.go +++ b/node/errors.go @@ -141,3 +141,6 @@ var ErrNilCreateTransactionArgs = errors.New("nil args for create transaction") // ErrNilNodeRunner signals that a nil node runner was provided var ErrNilNodeRunner = errors.New("nil node runner") + +// ErrNilNode signals that a nil node was provided +var ErrNilNode = errors.New("nil node") diff --git a/node/interface.go b/node/interface.go index 19dbc4513d3..75c18d5a4eb 100644 --- a/node/interface.go +++ b/node/interface.go @@ -66,11 +66,13 @@ type accountHandlerWithDataTrieMigrationStatus interface { 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 diff --git a/node/nodeFactory_test.go b/node/nodeFactory_test.go index cf70bd059d5..99fe43ab169 100644 --- a/node/nodeFactory_test.go +++ b/node/nodeFactory_test.go @@ -1,7 +1,8 @@ -package node +package node_test import ( - "github.com/stretchr/testify/assert" + "fmt" + "github.com/multiversx/mx-chain-go/node" "github.com/stretchr/testify/require" "testing" ) @@ -9,16 +10,17 @@ import ( func TestNewNodeFactory(t *testing.T) { t.Parallel() - nodeFactory := NewNodeFactory() + nodeFactory := node.NewNodeFactory() require.False(t, nodeFactory.IsInterfaceNil()) } func TestNodeFactory_CreateNewNode(t *testing.T) { t.Parallel() - nodeFactory := NewNodeFactory() + nodeFactory := node.NewNodeFactory() n, err := nodeFactory.CreateNewNode() - assert.Nil(t, err) - assert.NotNil(t, n) + require.Nil(t, err) + require.NotNil(t, n) + require.Equal(t, "*node.Node", fmt.Sprintf("%T", n)) } diff --git a/node/sovereignNode.go b/node/sovereignNode.go index 1fe8dc73e96..c38fc71d90f 100644 --- a/node/sovereignNode.go +++ b/node/sovereignNode.go @@ -2,27 +2,78 @@ package node import ( "context" + "github.com/multiversx/mx-chain-core-go/core" "github.com/multiversx/mx-chain-core-go/data/api" ) -type SovereignNode struct { +type sovereignNode struct { *Node } -func NewSovereignNode(node *Node) *SovereignNode { - return &SovereignNode{ - node, +// NewSovereignNode creates a new sovereignNode instance +func NewSovereignNode(node *Node) (*sovereignNode, error) { + if node == nil { + return nil, ErrNilNode } + + return &sovereignNode{ + node, + }, nil } -func (sn *SovereignNode) GetAllIssuedESDTs(tokenType string, ctx context.Context) ([]string, error) { +// GetAllIssuedESDTs returns all the issued esdt tokens, works only on metachain +func (sn *sovereignNode) GetAllIssuedESDTs(tokenType string, ctx context.Context) ([]string, error) { return sn.baseGetAllIssuedESDTs(tokenType, ctx) } -func (sn *SovereignNode) getTokensIDsWithFilter( - f filter, - options api.AccountQueryOptions, - ctx context.Context, -) ([]string, api.BlockInfo, error) { +// GetNFTTokenIDsRegisteredByAddress returns all the token identifiers for semi or non fungible tokens registered by the address +func (sn *sovereignNode) GetNFTTokenIDsRegisteredByAddress(address string, options api.AccountQueryOptions, ctx context.Context) ([]string, api.BlockInfo, error) { + addressBytes, err := sn.coreComponents.AddressPubKeyConverter().Decode(address) + if err != nil { + return nil, api.BlockInfo{}, err + } + + f := &getRegisteredNftsFilter{ + addressBytes: addressBytes, + } + return sn.baseGetTokensIDsWithFilter(f, options, ctx) +} + +// GetESDTsWithRole returns all the tokens with the given role for the given address +func (sn *sovereignNode) GetESDTsWithRole(address string, role string, options api.AccountQueryOptions, ctx context.Context) ([]string, api.BlockInfo, error) { + if !core.IsValidESDTRole(role) { + return nil, api.BlockInfo{}, ErrInvalidESDTRole + } + + addressBytes, err := sn.coreComponents.AddressPubKeyConverter().Decode(address) + if err != nil { + return nil, api.BlockInfo{}, err + } + + f := &getTokensWithRoleFilter{ + addressBytes: addressBytes, + role: role, + } return sn.baseGetTokensIDsWithFilter(f, options, ctx) } + +// GetESDTsRoles returns all the tokens identifiers and roles for the given address +func (sn *sovereignNode) GetESDTsRoles(address string, options api.AccountQueryOptions, ctx context.Context) (map[string][]string, api.BlockInfo, error) { + addressBytes, err := sn.coreComponents.AddressPubKeyConverter().Decode(address) + if err != nil { + return nil, api.BlockInfo{}, err + } + + tokensRoles := make(map[string][]string) + + f := &getAllTokensRolesFilter{ + addressBytes: addressBytes, + outputRoles: tokensRoles, + } + _, blockInfo, err := sn.baseGetTokensIDsWithFilter(f, options, ctx) + if err != nil { + return nil, api.BlockInfo{}, err + } + + return tokensRoles, blockInfo, nil +} diff --git a/node/sovereignNodeFactory.go b/node/sovereignNodeFactory.go index 60c60f43dbb..9b237d41e41 100644 --- a/node/sovereignNodeFactory.go +++ b/node/sovereignNodeFactory.go @@ -9,12 +9,15 @@ func NewSovereignNodeFactory() *sovereignNodeFactory { func (snf *sovereignNodeFactory) CreateNewNode(opts ...Option) (NodeHandler, error) { nd, err := NewNode(opts...) + if err != nil { + return nil, err + } + snd, err := NewSovereignNode(nd) if err != nil { return nil, err } - snd := NewSovereignNode(nd) return snd, nil } diff --git a/node/sovereignNodeFactory_test.go b/node/sovereignNodeFactory_test.go index c7621b6b0b2..a654d6089f6 100644 --- a/node/sovereignNodeFactory_test.go +++ b/node/sovereignNodeFactory_test.go @@ -1,24 +1,27 @@ -package node +package node_test import ( - "github.com/stretchr/testify/assert" - "github.com/stretchr/testify/require" + "fmt" "testing" + + "github.com/multiversx/mx-chain-go/node" + "github.com/stretchr/testify/require" ) func TestNewSovereignNodeFactory(t *testing.T) { t.Parallel() - sovereignNodeFactory := NewSovereignNodeFactory() + sovereignNodeFactory := node.NewSovereignNodeFactory() require.False(t, sovereignNodeFactory.IsInterfaceNil()) } func TestSovereignNodeFactory_CreateNewNode(t *testing.T) { t.Parallel() - sovereignNodeFactory := NewSovereignNodeFactory() + sovereignNodeFactory := node.NewSovereignNodeFactory() sn, err := sovereignNodeFactory.CreateNewNode() - assert.Nil(t, err) - assert.NotNil(t, sn) + require.Nil(t, err) + require.NotNil(t, sn) + require.Equal(t, "*node.sovereignNode", fmt.Sprintf("%T", sn)) } diff --git a/node/sovereignNode_test.go b/node/sovereignNode_test.go new file mode 100644 index 00000000000..10721c44d56 --- /dev/null +++ b/node/sovereignNode_test.go @@ -0,0 +1,354 @@ +package node_test + +import ( + "context" + "testing" + + "github.com/multiversx/mx-chain-core-go/core" + "github.com/multiversx/mx-chain-core-go/data/api" + "github.com/multiversx/mx-chain-go/common" + "github.com/multiversx/mx-chain-go/node" + "github.com/multiversx/mx-chain-go/node/mock" + "github.com/multiversx/mx-chain-go/state" + "github.com/multiversx/mx-chain-go/testscommon" + stateMock "github.com/multiversx/mx-chain-go/testscommon/state" + trieMock "github.com/multiversx/mx-chain-go/testscommon/trie" + "github.com/multiversx/mx-chain-go/vm/systemSmartContracts" + vmcommon "github.com/multiversx/mx-chain-vm-common-go" + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" +) + +func TestNewSovereignNode(t *testing.T) { + n, err := node.NewNode() + require.Nil(t, err) + require.NotNil(t, n) + + sn, err := node.NewSovereignNode(n) + require.Nil(t, err) + require.NotNil(t, sn) +} + +func TestNewSovereignNode_NilNodeShouldError(t *testing.T) { + t.Parallel() + + _, err := node.NewSovereignNode(nil) + assert.NotNil(t, err) +} + +func TestSovereignNode_GetAllIssuedESDTs(t *testing.T) { + t.Parallel() + + acc := createAcc([]byte("newaddress")) + esdtToken := []byte("TCK-RANDOM") + sftToken := []byte("SFT-RANDOM") + nftToken := []byte("NFT-RANDOM") + + esdtData := &systemSmartContracts.ESDTDataV2{TokenName: []byte("fungible"), TokenType: []byte(core.FungibleESDT)} + marshalledData, _ := getMarshalizer().Marshal(esdtData) + _ = acc.SaveKeyValue(esdtToken, marshalledData) + + sftData := &systemSmartContracts.ESDTDataV2{TokenName: []byte("semi fungible"), TokenType: []byte(core.SemiFungibleESDT)} + sftMarshalledData, _ := getMarshalizer().Marshal(sftData) + _ = acc.SaveKeyValue(sftToken, sftMarshalledData) + + nftData := &systemSmartContracts.ESDTDataV2{TokenName: []byte("non fungible"), TokenType: []byte(core.NonFungibleESDT)} + nftMarshalledData, _ := getMarshalizer().Marshal(nftData) + _ = acc.SaveKeyValue(nftToken, nftMarshalledData) + + esdtSuffix := append(esdtToken, acc.AddressBytes()...) + nftSuffix := append(nftToken, acc.AddressBytes()...) + sftSuffix := append(sftToken, acc.AddressBytes()...) + + acc.SetDataTrie( + &trieMock.TrieStub{ + GetAllLeavesOnChannelCalled: func(leavesChannels *common.TrieIteratorChannels, ctx context.Context, rootHash []byte, _ common.KeyBuilder, tlp common.TrieLeafParser) error { + go func() { + trieLeaf, _ := tlp.ParseLeaf(esdtToken, append(marshalledData, esdtSuffix...), core.NotSpecified) + leavesChannels.LeavesChan <- trieLeaf + + trieLeaf, _ = tlp.ParseLeaf(sftToken, append(sftMarshalledData, sftSuffix...), core.NotSpecified) + leavesChannels.LeavesChan <- trieLeaf + + trieLeaf, _ = tlp.ParseLeaf(nftToken, append(nftMarshalledData, nftSuffix...), core.NotSpecified) + leavesChannels.LeavesChan <- trieLeaf + close(leavesChannels.LeavesChan) + leavesChannels.ErrChan.Close() + }() + + return nil + }, + RootCalled: func() ([]byte, error) { + return nil, nil + }, + }) + + accDB := &stateMock.AccountsStub{ + RecreateTrieCalled: func(rootHash []byte) error { + return nil + }, + } + accDB.GetAccountWithBlockInfoCalled = func(address []byte, options common.RootHashHolder) (vmcommon.AccountHandler, common.BlockInfo, error) { + return acc, nil, nil + } + + coreComponents := getDefaultCoreComponents() + dataComponents := getDefaultDataComponents() + stateComponents := getDefaultStateComponents() + args := state.ArgsAccountsRepository{ + FinalStateAccountsWrapper: accDB, + CurrentStateAccountsWrapper: accDB, + HistoricalStateAccountsWrapper: accDB, + } + stateComponents.AccountsRepo, _ = state.NewAccountsRepository(args) + processComponents := getDefaultProcessComponents() + processComponents.ShardCoord = &mock.ShardCoordinatorMock{ + SelfShardId: core.MetachainShardId, + } + + n, _ := node.NewNode( + node.WithCoreComponents(coreComponents), + node.WithDataComponents(dataComponents), + node.WithStateComponents(stateComponents), + node.WithProcessComponents(processComponents), + ) + sn, _ := node.NewSovereignNode(n) + + value, err := sn.GetAllIssuedESDTs(core.FungibleESDT, context.Background()) + assert.Nil(t, err) + assert.Equal(t, 1, len(value)) + assert.Equal(t, string(esdtToken), value[0]) + + value, err = sn.GetAllIssuedESDTs(core.SemiFungibleESDT, context.Background()) + assert.Nil(t, err) + assert.Equal(t, 1, len(value)) + assert.Equal(t, string(sftToken), value[0]) + + value, err = sn.GetAllIssuedESDTs(core.NonFungibleESDT, context.Background()) + assert.Nil(t, err) + assert.Equal(t, 1, len(value)) + assert.Equal(t, string(nftToken), value[0]) + + value, err = sn.GetAllIssuedESDTs("", context.Background()) + assert.Nil(t, err) + assert.Equal(t, 3, len(value)) +} + +func TestSovereignNode_GetNFTTokenIDsRegisteredByAddress(t *testing.T) { + t.Parallel() + + addrBytes := testscommon.TestPubKeyAlice + acc := createAcc(addrBytes) + esdtToken := []byte("TCK-RANDOM") + + esdtData := &systemSmartContracts.ESDTDataV2{TokenName: []byte("fungible"), TokenType: []byte(core.SemiFungibleESDT), OwnerAddress: addrBytes} + marshalledData, _ := getMarshalizer().Marshal(esdtData) + _ = acc.SaveKeyValue(esdtToken, marshalledData) + + esdtSuffix := append(esdtToken, acc.AddressBytes()...) + + acc.SetDataTrie( + &trieMock.TrieStub{ + GetAllLeavesOnChannelCalled: func(leavesChannels *common.TrieIteratorChannels, ctx context.Context, rootHash []byte, _ common.KeyBuilder, tlp common.TrieLeafParser) error { + go func() { + trieLeaf, _ := tlp.ParseLeaf(esdtToken, append(marshalledData, esdtSuffix...), core.NotSpecified) + leavesChannels.LeavesChan <- trieLeaf + close(leavesChannels.LeavesChan) + leavesChannels.ErrChan.Close() + }() + + return nil + }, + RootCalled: func() ([]byte, error) { + return nil, nil + }, + }, + ) + + accDB := &stateMock.AccountsStub{ + RecreateTrieCalled: func(rootHash []byte) error { + return nil + }, + } + accDB.GetAccountWithBlockInfoCalled = func(address []byte, options common.RootHashHolder) (vmcommon.AccountHandler, common.BlockInfo, error) { + return acc, nil, nil + } + coreComponents := getDefaultCoreComponents() + stateComponents := getDefaultStateComponents() + dataComponents := getDefaultDataComponents() + args := state.ArgsAccountsRepository{ + FinalStateAccountsWrapper: accDB, + CurrentStateAccountsWrapper: accDB, + HistoricalStateAccountsWrapper: accDB, + } + stateComponents.AccountsRepo, _ = state.NewAccountsRepository(args) + processComponents := getDefaultProcessComponents() + processComponents.ShardCoord = &mock.ShardCoordinatorMock{ + SelfShardId: core.MetachainShardId, + } + n, _ := node.NewNode( + node.WithCoreComponents(coreComponents), + node.WithDataComponents(dataComponents), + node.WithStateComponents(stateComponents), + node.WithProcessComponents(processComponents), + ) + sn, _ := node.NewSovereignNode(n) + + tokenResult, _, err := sn.GetNFTTokenIDsRegisteredByAddress(testscommon.TestAddressAlice, api.AccountQueryOptions{}, context.Background()) + require.NoError(t, err) + require.Equal(t, 1, len(tokenResult)) + require.Equal(t, string(esdtToken), tokenResult[0]) +} + +func TestSovereignNode_GetESDTsWithRole(t *testing.T) { + t.Parallel() + + addrBytes := testscommon.TestPubKeyAlice + acc := createAcc(addrBytes) + esdtToken := []byte("TCK-RANDOM") + + specialRoles := []*systemSmartContracts.ESDTRoles{ + { + Address: addrBytes, + Roles: [][]byte{[]byte(core.ESDTRoleNFTAddQuantity), []byte(core.ESDTRoleLocalMint)}, + }, + } + + esdtData := &systemSmartContracts.ESDTDataV2{TokenName: []byte("fungible"), TokenType: []byte(core.FungibleESDT), SpecialRoles: specialRoles} + marshalledData, _ := getMarshalizer().Marshal(esdtData) + _ = acc.SaveKeyValue(esdtToken, marshalledData) + + esdtSuffix := append(esdtToken, acc.AddressBytes()...) + + acc.SetDataTrie( + &trieMock.TrieStub{ + GetAllLeavesOnChannelCalled: func(leavesChannels *common.TrieIteratorChannels, ctx context.Context, rootHash []byte, _ common.KeyBuilder, tlp common.TrieLeafParser) error { + go func() { + trieLeaf, _ := tlp.ParseLeaf(esdtToken, append(marshalledData, esdtSuffix...), core.NotSpecified) + leavesChannels.LeavesChan <- trieLeaf + close(leavesChannels.LeavesChan) + leavesChannels.ErrChan.Close() + }() + + return nil + }, + RootCalled: func() ([]byte, error) { + return nil, nil + }, + }) + + accDB := &stateMock.AccountsStub{ + RecreateTrieCalled: func(rootHash []byte) error { + return nil + }, + } + accDB.GetAccountWithBlockInfoCalled = func(address []byte, options common.RootHashHolder) (vmcommon.AccountHandler, common.BlockInfo, error) { + return acc, nil, nil + } + coreComponents := getDefaultCoreComponents() + dataComponents := getDefaultDataComponents() + stateComponents := getDefaultStateComponents() + args := state.ArgsAccountsRepository{ + FinalStateAccountsWrapper: accDB, + CurrentStateAccountsWrapper: accDB, + HistoricalStateAccountsWrapper: accDB, + } + stateComponents.AccountsRepo, _ = state.NewAccountsRepository(args) + processComponents := getDefaultProcessComponents() + processComponents.ShardCoord = &mock.ShardCoordinatorMock{ + SelfShardId: core.MetachainShardId, + } + n, _ := node.NewNode( + node.WithCoreComponents(coreComponents), + node.WithDataComponents(dataComponents), + node.WithStateComponents(stateComponents), + node.WithProcessComponents(processComponents), + ) + sn, _ := node.NewSovereignNode(n) + + tokenResult, _, err := sn.GetESDTsWithRole(testscommon.TestAddressAlice, core.ESDTRoleNFTAddQuantity, api.AccountQueryOptions{}, context.Background()) + require.NoError(t, err) + require.Equal(t, 1, len(tokenResult)) + require.Equal(t, string(esdtToken), tokenResult[0]) + + tokenResult, _, err = sn.GetESDTsWithRole(testscommon.TestAddressAlice, core.ESDTRoleLocalMint, api.AccountQueryOptions{}, context.Background()) + require.NoError(t, err) + require.Equal(t, 1, len(tokenResult)) + require.Equal(t, string(esdtToken), tokenResult[0]) + + tokenResult, _, err = sn.GetESDTsWithRole(testscommon.TestAddressAlice, core.ESDTRoleNFTCreate, api.AccountQueryOptions{}, context.Background()) + require.NoError(t, err) + require.Len(t, tokenResult, 0) +} + +func TestSovereignNode_GetESDTsRoles(t *testing.T) { + t.Parallel() + + addrBytes := testscommon.TestPubKeyAlice + acc := createAcc(addrBytes) + esdtToken := []byte("TCK-RANDOM") + + specialRoles := []*systemSmartContracts.ESDTRoles{ + { + Address: addrBytes, + Roles: [][]byte{[]byte(core.ESDTRoleNFTAddQuantity), []byte(core.ESDTRoleLocalMint)}, + }, + } + + esdtData := &systemSmartContracts.ESDTDataV2{TokenName: []byte("fungible"), TokenType: []byte(core.FungibleESDT), SpecialRoles: specialRoles} + marshalledData, _ := getMarshalizer().Marshal(esdtData) + + esdtSuffix := append(esdtToken, acc.AddressBytes()...) + + acc.SetDataTrie( + &trieMock.TrieStub{ + GetAllLeavesOnChannelCalled: func(leavesChannels *common.TrieIteratorChannels, ctx context.Context, rootHash []byte, _ common.KeyBuilder, tlp common.TrieLeafParser) error { + go func() { + trieLeaf, _ := tlp.ParseLeaf(esdtToken, append(marshalledData, esdtSuffix...), core.NotSpecified) + leavesChannels.LeavesChan <- trieLeaf + close(leavesChannels.LeavesChan) + leavesChannels.ErrChan.Close() + }() + + return nil + }, + RootCalled: func() ([]byte, error) { + return nil, nil + }, + }) + + accDB := &stateMock.AccountsStub{ + RecreateTrieCalled: func(rootHash []byte) error { + return nil + }, + } + accDB.GetAccountWithBlockInfoCalled = func(address []byte, options common.RootHashHolder) (vmcommon.AccountHandler, common.BlockInfo, error) { + return acc, nil, nil + } + coreComponents := getDefaultCoreComponents() + stateComponents := getDefaultStateComponents() + dataComponents := getDefaultDataComponents() + args := state.ArgsAccountsRepository{ + FinalStateAccountsWrapper: accDB, + CurrentStateAccountsWrapper: accDB, + HistoricalStateAccountsWrapper: accDB, + } + stateComponents.AccountsRepo, _ = state.NewAccountsRepository(args) + processComponents := getDefaultProcessComponents() + processComponents.ShardCoord = &mock.ShardCoordinatorMock{ + SelfShardId: core.MetachainShardId, + } + n, _ := node.NewNode( + node.WithCoreComponents(coreComponents), + node.WithDataComponents(dataComponents), + node.WithStateComponents(stateComponents), + node.WithProcessComponents(processComponents), + ) + sn, _ := node.NewSovereignNode(n) + + tokenResult, _, err := sn.GetESDTsRoles(testscommon.TestAddressAlice, api.AccountQueryOptions{}, context.Background()) + require.NoError(t, err) + require.Equal(t, map[string][]string{ + string(esdtToken): {core.ESDTRoleNFTAddQuantity, core.ESDTRoleLocalMint}, + }, tokenResult) +} From 1ca3072d5c7efe21433edc39b3c2f47c6c919d15 Mon Sep 17 00:00:00 2001 From: axenteoctavian Date: Thu, 4 Jan 2024 17:29:41 +0200 Subject: [PATCH 04/56] refactor sovereign components --- cmd/sovereignnode/sovereignNodeRunner.go | 29 +++++++++------- factory/api/apiResolverFactory.go | 34 ++++++++++--------- node/nodeRunner.go | 31 +++++++++-------- .../factory/delegatedListHandlerFactory.go | 13 ++++++- .../factory/directStakedListHandlerFactory.go | 13 ++++++- node/trieIterators/factory/interface.go | 16 +++++++++ .../sovereignDelegatedListHandlerFactory.go | 22 ++++++++++++ ...sovereignDirectStakedListHandlerFactory.go | 29 ++++++++++++++++ 8 files changed, 142 insertions(+), 45 deletions(-) create mode 100644 node/trieIterators/factory/interface.go create mode 100644 node/trieIterators/factory/sovereignDelegatedListHandlerFactory.go create mode 100644 node/trieIterators/factory/sovereignDirectStakedListHandlerFactory.go diff --git a/cmd/sovereignnode/sovereignNodeRunner.go b/cmd/sovereignnode/sovereignNodeRunner.go index acfccfe76f4..79f9c77f5fd 100644 --- a/cmd/sovereignnode/sovereignNodeRunner.go +++ b/cmd/sovereignnode/sovereignNodeRunner.go @@ -5,6 +5,7 @@ package main import ( "fmt" + trieIteratorsFactory "github.com/multiversx/mx-chain-go/node/trieIterators/factory" "io" "io/ioutil" "math/big" @@ -678,19 +679,21 @@ func (snr *sovereignNodeRunner) createApiFacade( log.Debug("creating api resolver structure") 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(), - GasScheduleNotifier: gasScheduleNotifier, - Bootstrapper: currentNode.GetConsensusComponents().Bootstrapper(), - AllowVMQueriesChan: allowVMQueriesChan, - StatusComponents: currentNode.GetStatusComponents(), - ChainRunType: common.ChainRunTypeSovereign, + Configs: configs.Configs, + CoreComponents: currentNode.GetCoreComponents(), + DataComponents: currentNode.GetDataComponents(), + StateComponents: currentNode.GetStateComponents(), + BootstrapComponents: currentNode.GetBootstrapComponents(), + CryptoComponents: currentNode.GetCryptoComponents(), + ProcessComponents: currentNode.GetProcessComponents(), + StatusCoreComponents: currentNode.GetStatusCoreComponents(), + GasScheduleNotifier: gasScheduleNotifier, + Bootstrapper: currentNode.GetConsensusComponents().Bootstrapper(), + AllowVMQueriesChan: allowVMQueriesChan, + StatusComponents: currentNode.GetStatusComponents(), + ChainRunType: common.ChainRunTypeSovereign, + DelegatedListHandler: trieIteratorsFactory.NewSovereignDelegatedListHandlerFactory(), + DirectStakedListHandler: trieIteratorsFactory.NewSovereignDirectStakedListHandlerFactory(), } apiResolver, err := apiComp.CreateApiResolver(apiResolverArgs) diff --git a/factory/api/apiResolverFactory.go b/factory/api/apiResolverFactory.go index 1a68340d0db..2ae2173b9a0 100644 --- a/factory/api/apiResolverFactory.go +++ b/factory/api/apiResolverFactory.go @@ -55,20 +55,22 @@ var log = logger.GetOrCreate("factory") // ApiResolverArgs holds the argument needed to create an API resolver type ApiResolverArgs struct { - Configs *config.Configs - CoreComponents factory.CoreComponentsHolder - DataComponents factory.DataComponentsHolder - StateComponents factory.StateComponentsHolder - BootstrapComponents factory.BootstrapComponentsHolder - CryptoComponents factory.CryptoComponentsHolder - ProcessComponents factory.ProcessComponentsHolder - StatusCoreComponents factory.StatusCoreComponentsHolder - StatusComponents factory.StatusComponentsHolder - GasScheduleNotifier common.GasScheduleNotifierAPI - Bootstrapper process.Bootstrapper - AllowVMQueriesChan chan struct{} - ProcessingMode common.NodeProcessingMode - ChainRunType common.ChainRunType + Configs *config.Configs + CoreComponents factory.CoreComponentsHolder + DataComponents factory.DataComponentsHolder + StateComponents factory.StateComponentsHolder + BootstrapComponents factory.BootstrapComponentsHolder + CryptoComponents factory.CryptoComponentsHolder + ProcessComponents factory.ProcessComponentsHolder + StatusCoreComponents factory.StatusCoreComponentsHolder + StatusComponents factory.StatusComponentsHolder + GasScheduleNotifier common.GasScheduleNotifierAPI + Bootstrapper process.Bootstrapper + AllowVMQueriesChan chan struct{} + ProcessingMode common.NodeProcessingMode + ChainRunType common.ChainRunType + DelegatedListHandler trieIteratorsFactory.DelegatedListHandler + DirectStakedListHandler trieIteratorsFactory.DirectStakedListHandler } type scQueryServiceArgs struct { @@ -201,12 +203,12 @@ func CreateApiResolver(args *ApiResolverArgs) (facade.ApiResolver, error) { return nil, err } - directStakedListHandler, err := trieIteratorsFactory.CreateDirectStakedListHandler(argsProcessors) + directStakedListHandler, err := args.DirectStakedListHandler.CreateDirectStakedListHandler(argsProcessors) if err != nil { return nil, err } - delegatedListHandler, err := trieIteratorsFactory.CreateDelegatedListHandler(argsProcessors) + delegatedListHandler, err := args.DelegatedListHandler.CreateDelegatedListHandler(argsProcessors) if err != nil { return nil, err } diff --git a/node/nodeRunner.go b/node/nodeRunner.go index 7c4d160e340..67990ac1532 100644 --- a/node/nodeRunner.go +++ b/node/nodeRunner.go @@ -2,6 +2,7 @@ package node import ( "fmt" + trieIteratorsFactory "github.com/multiversx/mx-chain-go/node/trieIterators/factory" "io" "math/big" "os" @@ -706,20 +707,22 @@ func (nr *nodeRunner) createApiFacade( log.Debug("creating api resolver structure") apiResolverArgs := &apiComp.ApiResolverArgs{ - Configs: configs, - CoreComponents: currentNode.coreComponents, - DataComponents: currentNode.dataComponents, - StateComponents: currentNode.stateComponents, - BootstrapComponents: currentNode.bootstrapComponents, - CryptoComponents: currentNode.cryptoComponents, - ProcessComponents: currentNode.processComponents, - StatusCoreComponents: currentNode.statusCoreComponents, - GasScheduleNotifier: gasScheduleNotifier, - Bootstrapper: currentNode.consensusComponents.Bootstrapper(), - AllowVMQueriesChan: allowVMQueriesChan, - StatusComponents: currentNode.statusComponents, - ProcessingMode: common.GetNodeProcessingMode(nr.configs.ImportDbConfig), - ChainRunType: common.ChainRunTypeRegular, + Configs: configs, + CoreComponents: currentNode.coreComponents, + DataComponents: currentNode.dataComponents, + StateComponents: currentNode.stateComponents, + BootstrapComponents: currentNode.bootstrapComponents, + CryptoComponents: currentNode.cryptoComponents, + ProcessComponents: currentNode.processComponents, + StatusCoreComponents: currentNode.statusCoreComponents, + GasScheduleNotifier: gasScheduleNotifier, + Bootstrapper: currentNode.consensusComponents.Bootstrapper(), + AllowVMQueriesChan: allowVMQueriesChan, + StatusComponents: currentNode.statusComponents, + ProcessingMode: common.GetNodeProcessingMode(nr.configs.ImportDbConfig), + ChainRunType: common.ChainRunTypeRegular, + DelegatedListHandler: trieIteratorsFactory.NewDelegatedListHandlerFactory(), + DirectStakedListHandler: trieIteratorsFactory.NewDirectStakedListHandlerFactory(), } apiResolver, err := apiComp.CreateApiResolver(apiResolverArgs) diff --git a/node/trieIterators/factory/delegatedListHandlerFactory.go b/node/trieIterators/factory/delegatedListHandlerFactory.go index 1c5e290c249..7e1357e8cc3 100644 --- a/node/trieIterators/factory/delegatedListHandlerFactory.go +++ b/node/trieIterators/factory/delegatedListHandlerFactory.go @@ -7,8 +7,15 @@ import ( "github.com/multiversx/mx-chain-go/node/trieIterators/disabled" ) +type delegatedListHandlerFactory struct { +} + +func NewDelegatedListHandlerFactory() *delegatedListHandlerFactory { + return &delegatedListHandlerFactory{} +} + // CreateDelegatedListHandler will create a new instance of DirectStakedListHandler -func CreateDelegatedListHandler(args trieIterators.ArgTrieIteratorProcessor) (external.DelegatedListHandler, error) { +func (d *delegatedListHandlerFactory) CreateDelegatedListHandler(args trieIterators.ArgTrieIteratorProcessor) (external.DelegatedListHandler, error) { //TODO add unit tests if args.ShardID != core.MetachainShardId { return disabled.NewDisabledDelegatedListProcessor(), nil @@ -16,3 +23,7 @@ func CreateDelegatedListHandler(args trieIterators.ArgTrieIteratorProcessor) (ex return trieIterators.NewDelegatedListProcessor(args) } + +func (d *delegatedListHandlerFactory) IsInterfaceNil() bool { + return d == nil +} diff --git a/node/trieIterators/factory/directStakedListHandlerFactory.go b/node/trieIterators/factory/directStakedListHandlerFactory.go index e0f023fe2b9..e0cf4f71c24 100644 --- a/node/trieIterators/factory/directStakedListHandlerFactory.go +++ b/node/trieIterators/factory/directStakedListHandlerFactory.go @@ -7,8 +7,15 @@ import ( "github.com/multiversx/mx-chain-go/node/trieIterators/disabled" ) +type directStakedListHandlerFactory struct { +} + +func NewDirectStakedListHandlerFactory() *directStakedListHandlerFactory { + return &directStakedListHandlerFactory{} +} + // CreateDirectStakedListHandler will create a new instance of DirectStakedListHandler -func CreateDirectStakedListHandler(args trieIterators.ArgTrieIteratorProcessor) (external.DirectStakedListHandler, error) { +func (ds *directStakedListHandlerFactory) CreateDirectStakedListHandler(args trieIterators.ArgTrieIteratorProcessor) (external.DirectStakedListHandler, error) { //TODO add unit tests if args.ShardID != core.MetachainShardId { return disabled.NewDisabledDirectStakedListProcessor(), nil @@ -16,3 +23,7 @@ func CreateDirectStakedListHandler(args trieIterators.ArgTrieIteratorProcessor) return trieIterators.NewDirectStakedListProcessor(args) } + +func (ds *directStakedListHandlerFactory) IsInterfaceNil() bool { + return ds == nil +} diff --git a/node/trieIterators/factory/interface.go b/node/trieIterators/factory/interface.go new file mode 100644 index 00000000000..636b55a3779 --- /dev/null +++ b/node/trieIterators/factory/interface.go @@ -0,0 +1,16 @@ +package factory + +import ( + "github.com/multiversx/mx-chain-go/node/external" + "github.com/multiversx/mx-chain-go/node/trieIterators" +) + +type DelegatedListHandler interface { + CreateDelegatedListHandler(args trieIterators.ArgTrieIteratorProcessor) (external.DelegatedListHandler, error) + IsInterfaceNil() bool +} + +type DirectStakedListHandler interface { + CreateDirectStakedListHandler(args trieIterators.ArgTrieIteratorProcessor) (external.DirectStakedListHandler, error) + IsInterfaceNil() bool +} diff --git a/node/trieIterators/factory/sovereignDelegatedListHandlerFactory.go b/node/trieIterators/factory/sovereignDelegatedListHandlerFactory.go new file mode 100644 index 00000000000..34668fe6a48 --- /dev/null +++ b/node/trieIterators/factory/sovereignDelegatedListHandlerFactory.go @@ -0,0 +1,22 @@ +package factory + +import ( + "github.com/multiversx/mx-chain-go/node/external" + "github.com/multiversx/mx-chain-go/node/trieIterators" +) + +type sovereignDelegatedListHandlerFactory struct { +} + +func NewSovereignDelegatedListHandlerFactory() *sovereignDelegatedListHandlerFactory { + return &sovereignDelegatedListHandlerFactory{} +} + +// CreateDelegatedListHandler will create a new instance of DirectStakedListHandler +func (sd *sovereignDelegatedListHandlerFactory) CreateDelegatedListHandler(args trieIterators.ArgTrieIteratorProcessor) (external.DelegatedListHandler, error) { + return trieIterators.NewDelegatedListProcessor(args) +} + +func (sd *sovereignDelegatedListHandlerFactory) IsInterfaceNil() bool { + return sd == nil +} diff --git a/node/trieIterators/factory/sovereignDirectStakedListHandlerFactory.go b/node/trieIterators/factory/sovereignDirectStakedListHandlerFactory.go new file mode 100644 index 00000000000..60417a35e24 --- /dev/null +++ b/node/trieIterators/factory/sovereignDirectStakedListHandlerFactory.go @@ -0,0 +1,29 @@ +package factory + +import ( + "github.com/multiversx/mx-chain-core-go/core" + "github.com/multiversx/mx-chain-go/node/external" + "github.com/multiversx/mx-chain-go/node/trieIterators" + "github.com/multiversx/mx-chain-go/node/trieIterators/disabled" +) + +type sovereignDirectStakedListHandlerFactory struct { +} + +func NewSovereignDirectStakedListHandlerFactory() *sovereignDirectStakedListHandlerFactory { + return &sovereignDirectStakedListHandlerFactory{} +} + +// CreateDirectStakedListHandler will create a new instance of DirectStakedListHandler +func (ds *sovereignDirectStakedListHandlerFactory) CreateDirectStakedListHandler(args trieIterators.ArgTrieIteratorProcessor) (external.DirectStakedListHandler, error) { + //TODO add unit tests + if args.ShardID != core.MetachainShardId { + return disabled.NewDisabledDirectStakedListProcessor(), nil + } + + return trieIterators.NewDirectStakedListProcessor(args) +} + +func (ds *sovereignDirectStakedListHandlerFactory) IsInterfaceNil() bool { + return ds == nil +} From b29fe099eb592e93f35d85d8a48d4d8d14da1355 Mon Sep 17 00:00:00 2001 From: axenteoctavian Date: Thu, 4 Jan 2024 17:37:43 +0200 Subject: [PATCH 05/56] fixes for fabric --- integrationTests/testProcessorNodeWithTestWebServer.go | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/integrationTests/testProcessorNodeWithTestWebServer.go b/integrationTests/testProcessorNodeWithTestWebServer.go index 163a10c39e4..e9c54afc005 100644 --- a/integrationTests/testProcessorNodeWithTestWebServer.go +++ b/integrationTests/testProcessorNodeWithTestWebServer.go @@ -212,10 +212,10 @@ func createFacadeComponents(tpn *TestProcessorNode) nodeFacade.ApiResolver { totalStakedValueHandler, err := factory.CreateTotalStakedValueHandler(args) log.LogIfError(err) - directStakedListHandler, err := factory.CreateDirectStakedListHandler(args) + directStakedListHandler, err := factory.NewDirectStakedListHandlerFactory().CreateDirectStakedListHandler(args) log.LogIfError(err) - delegatedListHandler, err := factory.CreateDelegatedListHandler(args) + delegatedListHandler, err := factory.NewDelegatedListHandlerFactory().CreateDelegatedListHandler(args) log.LogIfError(err) logsFacade := &testscommon.LogsFacadeStub{} From 8da93808bcd70d023f02b654e105fa6de312f4aa Mon Sep 17 00:00:00 2001 From: axenteoctavian Date: Fri, 5 Jan 2024 11:18:18 +0200 Subject: [PATCH 06/56] fixes and unit tests --- .../factory/delegatedListHandlerFactory.go | 3 +- .../delegatedListHandlerFactory_test.go | 18 +++++--- .../factory/directStakedListHandlerFactory.go | 3 +- .../directStakedListHandlerFactory_test.go | 18 +++++--- .../sovereignDelegatedListHandlerFactory.go | 2 + ...vereignDelegatedListHandlerFactory_test.go | 41 +++++++++++++++++++ ...sovereignDirectStakedListHandlerFactory.go | 9 +--- ...eignDirectStakedListHandlerFactory_test.go | 41 +++++++++++++++++++ 8 files changed, 116 insertions(+), 19 deletions(-) create mode 100644 node/trieIterators/factory/sovereignDelegatedListHandlerFactory_test.go create mode 100644 node/trieIterators/factory/sovereignDirectStakedListHandlerFactory_test.go diff --git a/node/trieIterators/factory/delegatedListHandlerFactory.go b/node/trieIterators/factory/delegatedListHandlerFactory.go index 7e1357e8cc3..6b39592c109 100644 --- a/node/trieIterators/factory/delegatedListHandlerFactory.go +++ b/node/trieIterators/factory/delegatedListHandlerFactory.go @@ -10,13 +10,13 @@ import ( type delegatedListHandlerFactory struct { } +// NewDelegatedListHandlerFactory create a new delegated list handler func NewDelegatedListHandlerFactory() *delegatedListHandlerFactory { return &delegatedListHandlerFactory{} } // CreateDelegatedListHandler will create a new instance of DirectStakedListHandler func (d *delegatedListHandlerFactory) CreateDelegatedListHandler(args trieIterators.ArgTrieIteratorProcessor) (external.DelegatedListHandler, error) { - //TODO add unit tests if args.ShardID != core.MetachainShardId { return disabled.NewDisabledDelegatedListProcessor(), nil } @@ -24,6 +24,7 @@ func (d *delegatedListHandlerFactory) CreateDelegatedListHandler(args trieIterat return trieIterators.NewDelegatedListProcessor(args) } +// IsInterfaceNil checks if the underlying pointer is nil func (d *delegatedListHandlerFactory) IsInterfaceNil() bool { return d == nil } diff --git a/node/trieIterators/factory/delegatedListHandlerFactory_test.go b/node/trieIterators/factory/delegatedListHandlerFactory_test.go index 0ea20418ada..6330d7f09ea 100644 --- a/node/trieIterators/factory/delegatedListHandlerFactory_test.go +++ b/node/trieIterators/factory/delegatedListHandlerFactory_test.go @@ -1,4 +1,4 @@ -package factory +package factory_test import ( "fmt" @@ -8,25 +8,33 @@ import ( "github.com/multiversx/mx-chain-core-go/core" "github.com/multiversx/mx-chain-go/node/mock" "github.com/multiversx/mx-chain-go/node/trieIterators" + trieIteratorsFactory "github.com/multiversx/mx-chain-go/node/trieIterators/factory" "github.com/multiversx/mx-chain-go/testscommon" stateMock "github.com/multiversx/mx-chain-go/testscommon/state" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" ) -func TestCreateDelegatedListHandlerHandler_Disabled(t *testing.T) { +func TestNewDelegatedListHandlerFactory(t *testing.T) { + t.Parallel() + + delegatedListHandlerFactory := trieIteratorsFactory.NewDelegatedListHandlerFactory() + require.False(t, delegatedListHandlerFactory.IsInterfaceNil()) +} + +func TestDelegatedListHandlerFactory_CreateDelegatedListHandler_Disabled(t *testing.T) { t.Parallel() args := trieIterators.ArgTrieIteratorProcessor{ ShardID: 0, } - delegatedListHandler, err := CreateDelegatedListHandler(args) + delegatedListHandler, err := trieIteratorsFactory.NewDelegatedListHandlerFactory().CreateDelegatedListHandler(args) require.Nil(t, err) assert.Equal(t, "*disabled.delegatedListProcessor", fmt.Sprintf("%T", delegatedListHandler)) } -func TestCreateDelegatedListHandlerHandler_DelegatedListProcessor(t *testing.T) { +func TestDelegatedListHandlerFactory_CreateDelegatedListHandler_DelegatedListProcessor(t *testing.T) { t.Parallel() args := trieIterators.ArgTrieIteratorProcessor{ @@ -39,7 +47,7 @@ func TestCreateDelegatedListHandlerHandler_DelegatedListProcessor(t *testing.T) QueryService: &mock.SCQueryServiceStub{}, } - delegatedListHandler, err := CreateDelegatedListHandler(args) + delegatedListHandler, err := trieIteratorsFactory.NewDelegatedListHandlerFactory().CreateDelegatedListHandler(args) require.Nil(t, err) assert.Equal(t, "*trieIterators.delegatedListProcessor", fmt.Sprintf("%T", delegatedListHandler)) } diff --git a/node/trieIterators/factory/directStakedListHandlerFactory.go b/node/trieIterators/factory/directStakedListHandlerFactory.go index e0cf4f71c24..7d26a152315 100644 --- a/node/trieIterators/factory/directStakedListHandlerFactory.go +++ b/node/trieIterators/factory/directStakedListHandlerFactory.go @@ -10,13 +10,13 @@ import ( type directStakedListHandlerFactory struct { } +// NewDirectStakedListHandlerFactory create a new direct staked list handler func NewDirectStakedListHandlerFactory() *directStakedListHandlerFactory { return &directStakedListHandlerFactory{} } // CreateDirectStakedListHandler will create a new instance of DirectStakedListHandler func (ds *directStakedListHandlerFactory) CreateDirectStakedListHandler(args trieIterators.ArgTrieIteratorProcessor) (external.DirectStakedListHandler, error) { - //TODO add unit tests if args.ShardID != core.MetachainShardId { return disabled.NewDisabledDirectStakedListProcessor(), nil } @@ -24,6 +24,7 @@ func (ds *directStakedListHandlerFactory) CreateDirectStakedListHandler(args tri return trieIterators.NewDirectStakedListProcessor(args) } +// IsInterfaceNil checks if the underlying pointer is nil func (ds *directStakedListHandlerFactory) IsInterfaceNil() bool { return ds == nil } diff --git a/node/trieIterators/factory/directStakedListHandlerFactory_test.go b/node/trieIterators/factory/directStakedListHandlerFactory_test.go index 68a8b2de929..29912682189 100644 --- a/node/trieIterators/factory/directStakedListHandlerFactory_test.go +++ b/node/trieIterators/factory/directStakedListHandlerFactory_test.go @@ -1,4 +1,4 @@ -package factory +package factory_test import ( "fmt" @@ -8,25 +8,33 @@ import ( "github.com/multiversx/mx-chain-core-go/core" "github.com/multiversx/mx-chain-go/node/mock" "github.com/multiversx/mx-chain-go/node/trieIterators" + trieIteratorsFactory "github.com/multiversx/mx-chain-go/node/trieIterators/factory" "github.com/multiversx/mx-chain-go/testscommon" stateMock "github.com/multiversx/mx-chain-go/testscommon/state" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" ) -func TestCreateDirectStakedListHandlerHandler_Disabled(t *testing.T) { +func TestNewDirectStakedListHandlerFactory(t *testing.T) { + t.Parallel() + + directStakedListHandlerFactory := trieIteratorsFactory.NewDirectStakedListHandlerFactory() + require.False(t, directStakedListHandlerFactory.IsInterfaceNil()) +} + +func TestDirectStakedListHandlerFactory_CreateDirectStakedListHandler_Disabled(t *testing.T) { t.Parallel() args := trieIterators.ArgTrieIteratorProcessor{ ShardID: 0, } - directStakedListHandler, err := CreateDirectStakedListHandler(args) + directStakedListHandler, err := trieIteratorsFactory.NewDirectStakedListHandlerFactory().CreateDirectStakedListHandler(args) require.Nil(t, err) assert.Equal(t, "*disabled.directStakedListProcessor", fmt.Sprintf("%T", directStakedListHandler)) } -func TestCreateDirectStakedListHandlerHandler_DirectStakedListProcessor(t *testing.T) { +func TestDirectStakedListHandlerFactory_CreateDirectStakedListHandler_DirectStakedListProcessor(t *testing.T) { t.Parallel() args := trieIterators.ArgTrieIteratorProcessor{ @@ -39,7 +47,7 @@ func TestCreateDirectStakedListHandlerHandler_DirectStakedListProcessor(t *testi QueryService: &mock.SCQueryServiceStub{}, } - directStakedListHandler, err := CreateDirectStakedListHandler(args) + directStakedListHandler, err := trieIteratorsFactory.NewDirectStakedListHandlerFactory().CreateDirectStakedListHandler(args) require.Nil(t, err) assert.Equal(t, "*trieIterators.directStakedListProcessor", fmt.Sprintf("%T", directStakedListHandler)) } diff --git a/node/trieIterators/factory/sovereignDelegatedListHandlerFactory.go b/node/trieIterators/factory/sovereignDelegatedListHandlerFactory.go index 34668fe6a48..7b8f52dbbbb 100644 --- a/node/trieIterators/factory/sovereignDelegatedListHandlerFactory.go +++ b/node/trieIterators/factory/sovereignDelegatedListHandlerFactory.go @@ -8,6 +8,7 @@ import ( type sovereignDelegatedListHandlerFactory struct { } +// NewSovereignDelegatedListHandlerFactory create a new sovereign delegated list handler func NewSovereignDelegatedListHandlerFactory() *sovereignDelegatedListHandlerFactory { return &sovereignDelegatedListHandlerFactory{} } @@ -17,6 +18,7 @@ func (sd *sovereignDelegatedListHandlerFactory) CreateDelegatedListHandler(args return trieIterators.NewDelegatedListProcessor(args) } +// IsInterfaceNil checks if the underlying pointer is nil func (sd *sovereignDelegatedListHandlerFactory) IsInterfaceNil() bool { return sd == nil } diff --git a/node/trieIterators/factory/sovereignDelegatedListHandlerFactory_test.go b/node/trieIterators/factory/sovereignDelegatedListHandlerFactory_test.go new file mode 100644 index 00000000000..d842966748c --- /dev/null +++ b/node/trieIterators/factory/sovereignDelegatedListHandlerFactory_test.go @@ -0,0 +1,41 @@ +package factory_test + +import ( + "fmt" + "sync" + "testing" + + "github.com/multiversx/mx-chain-core-go/core" + "github.com/multiversx/mx-chain-go/node/mock" + "github.com/multiversx/mx-chain-go/node/trieIterators" + trieIteratorsFactory "github.com/multiversx/mx-chain-go/node/trieIterators/factory" + "github.com/multiversx/mx-chain-go/testscommon" + stateMock "github.com/multiversx/mx-chain-go/testscommon/state" + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" +) + +func TestNewSovereignDelegatedListHandlerFactory(t *testing.T) { + t.Parallel() + + sovereignDelegatedListHandlerFactory := trieIteratorsFactory.NewSovereignDelegatedListHandlerFactory() + require.False(t, sovereignDelegatedListHandlerFactory.IsInterfaceNil()) +} + +func TestSovereignDelegatedListHandlerFactory_CreateDelegatedListHandler_DelegatedListProcessor(t *testing.T) { + t.Parallel() + + args := trieIterators.ArgTrieIteratorProcessor{ + ShardID: core.MetachainShardId, + Accounts: &trieIterators.AccountsWrapper{ + Mutex: &sync.Mutex{}, + AccountsAdapter: &stateMock.AccountsStub{}, + }, + PublicKeyConverter: &testscommon.PubkeyConverterMock{}, + QueryService: &mock.SCQueryServiceStub{}, + } + + sovereignDelegatedListHandler, err := trieIteratorsFactory.NewSovereignDelegatedListHandlerFactory().CreateDelegatedListHandler(args) + require.Nil(t, err) + assert.Equal(t, "*trieIterators.delegatedListProcessor", fmt.Sprintf("%T", sovereignDelegatedListHandler)) +} diff --git a/node/trieIterators/factory/sovereignDirectStakedListHandlerFactory.go b/node/trieIterators/factory/sovereignDirectStakedListHandlerFactory.go index 60417a35e24..b9b236d6872 100644 --- a/node/trieIterators/factory/sovereignDirectStakedListHandlerFactory.go +++ b/node/trieIterators/factory/sovereignDirectStakedListHandlerFactory.go @@ -1,29 +1,24 @@ package factory import ( - "github.com/multiversx/mx-chain-core-go/core" "github.com/multiversx/mx-chain-go/node/external" "github.com/multiversx/mx-chain-go/node/trieIterators" - "github.com/multiversx/mx-chain-go/node/trieIterators/disabled" ) type sovereignDirectStakedListHandlerFactory struct { } +// NewSovereignDirectStakedListHandlerFactory create a new sovereign direct staked list handler func NewSovereignDirectStakedListHandlerFactory() *sovereignDirectStakedListHandlerFactory { return &sovereignDirectStakedListHandlerFactory{} } // CreateDirectStakedListHandler will create a new instance of DirectStakedListHandler func (ds *sovereignDirectStakedListHandlerFactory) CreateDirectStakedListHandler(args trieIterators.ArgTrieIteratorProcessor) (external.DirectStakedListHandler, error) { - //TODO add unit tests - if args.ShardID != core.MetachainShardId { - return disabled.NewDisabledDirectStakedListProcessor(), nil - } - return trieIterators.NewDirectStakedListProcessor(args) } +// IsInterfaceNil checks if the underlying pointer is nil func (ds *sovereignDirectStakedListHandlerFactory) IsInterfaceNil() bool { return ds == nil } diff --git a/node/trieIterators/factory/sovereignDirectStakedListHandlerFactory_test.go b/node/trieIterators/factory/sovereignDirectStakedListHandlerFactory_test.go new file mode 100644 index 00000000000..f53e8ca819e --- /dev/null +++ b/node/trieIterators/factory/sovereignDirectStakedListHandlerFactory_test.go @@ -0,0 +1,41 @@ +package factory_test + +import ( + "fmt" + "github.com/multiversx/mx-chain-go/node/trieIterators" + "sync" + "testing" + + "github.com/multiversx/mx-chain-core-go/core" + "github.com/multiversx/mx-chain-go/node/mock" + trieIteratorsFactory "github.com/multiversx/mx-chain-go/node/trieIterators/factory" + "github.com/multiversx/mx-chain-go/testscommon" + stateMock "github.com/multiversx/mx-chain-go/testscommon/state" + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" +) + +func TestNewSovereignDirectStakedListHandlerFactory(t *testing.T) { + t.Parallel() + + directStakedListHandlerFactory := trieIteratorsFactory.NewDirectStakedListHandlerFactory() + require.False(t, directStakedListHandlerFactory.IsInterfaceNil()) +} + +func TestSovereignDirectStakedListHandlerFactory_CreateDirectStakedListHandler_DirectStakedListProcessor(t *testing.T) { + t.Parallel() + + args := trieIterators.ArgTrieIteratorProcessor{ + ShardID: core.MetachainShardId, + Accounts: &trieIterators.AccountsWrapper{ + Mutex: &sync.Mutex{}, + AccountsAdapter: &stateMock.AccountsStub{}, + }, + PublicKeyConverter: &testscommon.PubkeyConverterMock{}, + QueryService: &mock.SCQueryServiceStub{}, + } + + sovereignDirectStakedListHandler, err := trieIteratorsFactory.NewSovereignDirectStakedListHandlerFactory().CreateDirectStakedListHandler(args) + require.Nil(t, err) + assert.Equal(t, "*trieIterators.directStakedListProcessor", fmt.Sprintf("%T", sovereignDirectStakedListHandler)) +} From c0e0bc0c497f567217606efe9167bc4914df4c30 Mon Sep 17 00:00:00 2001 From: axenteoctavian Date: Fri, 5 Jan 2024 11:42:37 +0200 Subject: [PATCH 07/56] import clean fix --- cmd/sovereignnode/sovereignNodeRunner.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/cmd/sovereignnode/sovereignNodeRunner.go b/cmd/sovereignnode/sovereignNodeRunner.go index 79f9c77f5fd..bc4ff97e12b 100644 --- a/cmd/sovereignnode/sovereignNodeRunner.go +++ b/cmd/sovereignnode/sovereignNodeRunner.go @@ -5,7 +5,6 @@ package main import ( "fmt" - trieIteratorsFactory "github.com/multiversx/mx-chain-go/node/trieIterators/factory" "io" "io/ioutil" "math/big" @@ -62,6 +61,7 @@ import ( "github.com/multiversx/mx-chain-go/health" "github.com/multiversx/mx-chain-go/node" "github.com/multiversx/mx-chain-go/node/metrics" + trieIteratorsFactory "github.com/multiversx/mx-chain-go/node/trieIterators/factory" "github.com/multiversx/mx-chain-go/process" "github.com/multiversx/mx-chain-go/process/block/preprocess" "github.com/multiversx/mx-chain-go/process/factory/interceptorscontainer" From 7e70b5b57d2173fe4c74ca0f1e66654565b0795a Mon Sep 17 00:00:00 2001 From: axenteoctavian Date: Fri, 5 Jan 2024 11:53:22 +0200 Subject: [PATCH 08/56] function comments added --- node/node.go | 3 +++ node/nodeFactory.go | 3 +++ node/sovereignNodeFactory.go | 3 +++ 3 files changed, 9 insertions(+) diff --git a/node/node.go b/node/node.go index a6730f4ef81..cbd82d109f5 100644 --- a/node/node.go +++ b/node/node.go @@ -213,6 +213,7 @@ func (n *Node) GetAllIssuedESDTs(tokenType string, ctx context.Context) ([]strin return n.baseGetAllIssuedESDTs(tokenType, ctx) } +// baseGetAllIssuedESDTs returns all the issued esdt tokens func (n *Node) baseGetAllIssuedESDTs(tokenType string, ctx context.Context) ([]string, error) { userAccount, _, err := n.loadUserAccountHandlerByPubKey(vm.ESDTSCAddress, api.AccountQueryOptions{}) if err != nil { @@ -438,6 +439,7 @@ func (n *Node) GetESDTData(address, tokenID string, nonce uint64, options api.Ac return esdtToken, blockInfo, nil } +// getTokensIDsWithFilter returns token IDs based on filters, works only on metachain func (n *Node) getTokensIDsWithFilter( f filter, options api.AccountQueryOptions, @@ -450,6 +452,7 @@ func (n *Node) getTokensIDsWithFilter( return n.baseGetTokensIDsWithFilter(f, options, ctx) } +// baseGetTokensIDsWithFilter returns token IDs based on filters func (n *Node) baseGetTokensIDsWithFilter( f filter, options api.AccountQueryOptions, diff --git a/node/nodeFactory.go b/node/nodeFactory.go index bed46a03def..f76910bfd8d 100644 --- a/node/nodeFactory.go +++ b/node/nodeFactory.go @@ -3,10 +3,12 @@ package node type nodeFactory struct { } +// NewNodeFactory creates a new node factory instance func NewNodeFactory() *nodeFactory { return &nodeFactory{} } +// CreateNewNode will create a new NodeHandler func (nf *nodeFactory) CreateNewNode(opts ...Option) (NodeHandler, error) { n, err := NewNode(opts...) @@ -17,6 +19,7 @@ func (nf *nodeFactory) CreateNewNode(opts ...Option) (NodeHandler, error) { return n, nil } +// IsInterfaceNil checks if the underlying pointer is nil func (nf *nodeFactory) IsInterfaceNil() bool { return nf == nil } diff --git a/node/sovereignNodeFactory.go b/node/sovereignNodeFactory.go index 9b237d41e41..c0c485304bb 100644 --- a/node/sovereignNodeFactory.go +++ b/node/sovereignNodeFactory.go @@ -3,10 +3,12 @@ package node type sovereignNodeFactory struct { } +// NewSovereignNodeFactory creates a new sovereign node factory instance func NewSovereignNodeFactory() *sovereignNodeFactory { return &sovereignNodeFactory{} } +// CreateNewNode will create a new NodeHandler func (snf *sovereignNodeFactory) CreateNewNode(opts ...Option) (NodeHandler, error) { nd, err := NewNode(opts...) if err != nil { @@ -21,6 +23,7 @@ func (snf *sovereignNodeFactory) CreateNewNode(opts ...Option) (NodeHandler, err return snd, nil } +// IsInterfaceNil checks if the underlying pointer is nil func (snf *sovereignNodeFactory) IsInterfaceNil() bool { return snf == nil } From ff2d9b61a4ed669f68be9a90ab104476e9b984c9 Mon Sep 17 00:00:00 2001 From: axenteoctavian Date: Mon, 8 Jan 2024 10:13:58 +0200 Subject: [PATCH 09/56] unit tests fixes --- factory/api/apiResolverFactory.go | 9 +++++++++ factory/api/apiResolverFactory_test.go | 5 ++++- factory/errors.go | 9 +++++++++ 3 files changed, 22 insertions(+), 1 deletion(-) create mode 100644 factory/errors.go diff --git a/factory/api/apiResolverFactory.go b/factory/api/apiResolverFactory.go index 2ae2173b9a0..af42de00ed3 100644 --- a/factory/api/apiResolverFactory.go +++ b/factory/api/apiResolverFactory.go @@ -7,6 +7,7 @@ import ( "sync" "github.com/multiversx/mx-chain-core-go/core" + "github.com/multiversx/mx-chain-core-go/core/check" "github.com/multiversx/mx-chain-core-go/data" "github.com/multiversx/mx-chain-core-go/marshal" "github.com/multiversx/mx-chain-go/common" @@ -116,6 +117,14 @@ type scQueryElementArgs struct { // TODO: refactor to further decrease node's codebase func CreateApiResolver(args *ApiResolverArgs) (facade.ApiResolver, error) { apiWorkingDir := filepath.Join(args.Configs.FlagsConfig.WorkingDir, common.TemporaryPath) + + if check.IfNilReflect(args.DelegatedListHandler) { + return nil, factory.ErrorNilDelegatedListHandler + } + if check.IfNilReflect(args.DirectStakedListHandler) { + return nil, factory.ErrorNilDirectStakedListHandler + } + argsSCQuery := &scQueryServiceArgs{ generalConfig: args.Configs.GeneralConfig, epochConfig: args.Configs.EpochConfig, diff --git a/factory/api/apiResolverFactory_test.go b/factory/api/apiResolverFactory_test.go index 3c547b84b5b..80783ae8217 100644 --- a/factory/api/apiResolverFactory_test.go +++ b/factory/api/apiResolverFactory_test.go @@ -15,6 +15,7 @@ import ( "github.com/multiversx/mx-chain-go/factory/bootstrap" "github.com/multiversx/mx-chain-go/factory/mock" testsMocks "github.com/multiversx/mx-chain-go/integrationTests/mock" + trieIteratorsFactory "github.com/multiversx/mx-chain-go/node/trieIterators/factory" "github.com/multiversx/mx-chain-go/process" "github.com/multiversx/mx-chain-go/process/sync/disabled" "github.com/multiversx/mx-chain-go/state" @@ -108,7 +109,9 @@ func createMockArgs(t *testing.T) *api.ApiResolverArgs { StatusComponents: &mainFactoryMocks.StatusComponentsStub{ ManagedPeersMonitorField: &testscommon.ManagedPeersMonitorStub{}, }, - ChainRunType: common.ChainRunTypeRegular, + ChainRunType: common.ChainRunTypeRegular, + DelegatedListHandler: trieIteratorsFactory.NewDelegatedListHandlerFactory(), + DirectStakedListHandler: trieIteratorsFactory.NewDirectStakedListHandlerFactory(), } } diff --git a/factory/errors.go b/factory/errors.go new file mode 100644 index 00000000000..e74065f89f1 --- /dev/null +++ b/factory/errors.go @@ -0,0 +1,9 @@ +package factory + +import "errors" + +// ErrorNilDelegatedListHandler signal that returned account is wrong +var ErrorNilDelegatedListHandler = errors.New("nil DelegatedListHandler") + +// ErrorNilDirectStakedListHandler signal that returned account is wrong +var ErrorNilDirectStakedListHandler = errors.New("nil DirectStakedListHandler") From dbe482ee5b9e485de26439b7d3e489dad988f490 Mon Sep 17 00:00:00 2001 From: axenteoctavian Date: Mon, 8 Jan 2024 17:45:30 +0200 Subject: [PATCH 10/56] apiResolverFactory refactor --- factory/api/apiResolverFactory.go | 79 ++++++++++++++++++-------- factory/api/apiResolverFactory_test.go | 2 +- 2 files changed, 56 insertions(+), 25 deletions(-) diff --git a/factory/api/apiResolverFactory.go b/factory/api/apiResolverFactory.go index 1a68340d0db..403d57360be 100644 --- a/factory/api/apiResolverFactory.go +++ b/factory/api/apiResolverFactory.go @@ -27,6 +27,7 @@ import ( "github.com/multiversx/mx-chain-go/process" "github.com/multiversx/mx-chain-go/process/coordinator" "github.com/multiversx/mx-chain-go/process/economics" + factory2 "github.com/multiversx/mx-chain-go/process/factory" "github.com/multiversx/mx-chain-go/process/factory/metachain" "github.com/multiversx/mx-chain-go/process/factory/shard" "github.com/multiversx/mx-chain-go/process/smartContract" @@ -406,19 +407,32 @@ func createScQueryElement( MissingTrieNodesNotifier: syncer.NewMissingTrieNodesNotifier(), } - var apiBlockchain data.ChainHandler + apiBlockchain, err := blockchain.NewMetaChain(disabled.NewAppStatusHandler()) + if err != nil { + return nil, err + } + argsHook.BlockChain = apiBlockchain + + var accAdapter state.AccountsAdapterAPI var vmFactory process.VirtualMachinesContainerFactory maxGasForVmQueries := args.generalConfig.VirtualMachine.GasConfig.ShardMaxGasPerVmQuery if args.processComponents.ShardCoordinator().SelfId() == core.MetachainShardId { maxGasForVmQueries = args.generalConfig.VirtualMachine.GasConfig.MetaMaxGasPerVmQuery - apiBlockchain, vmFactory, err = createMetaVmContainerFactory(args, argsHook) + + accountsAdapterApi, err := createNewAccountsAdapterApi(args, apiBlockchain) + if err != nil { + return nil, err + } + argsHook.Accounts = accountsAdapterApi + + vmFactory, err = createMetaVmContainerFactory(args, argsHook) } else { - apiBlockchain, vmFactory, err = createShardVmContainerFactory(args, argsHook) + accAdapter, vmFactory, err = createShardVmContainerFactory(args, argsHook) + argsHook.Accounts = accAdapter } if err != nil { return nil, err } - log.Debug("maximum gas per VM Query", "value", maxGasForVmQueries) vmContainer, err := vmFactory.Create() @@ -426,6 +440,13 @@ func createScQueryElement( return nil, err } + if args.chainRunType == common.ChainRunTypeSovereign { + err = addSystemVMToContainer(args, vmContainer, argsHook) + if err != nil { + return nil, err + } + } + err = vmFactory.BlockChainHookImpl().SetVMContainer(vmContainer) if err != nil { return nil, err @@ -457,23 +478,39 @@ func createScQueryElement( return smartContract.NewSCQueryService(argsNewSCQueryService) } -func createMetaVmContainerFactory(args *scQueryElementArgs, argsHook hooks.ArgBlockChainHook) (data.ChainHandler, process.VirtualMachinesContainerFactory, error) { - apiBlockchain, err := blockchain.NewMetaChain(disabled.NewAppStatusHandler()) +func addSystemVMToContainer(args *scQueryElementArgs, vmContainer process.VirtualMachinesContainer, argsHook hooks.ArgBlockChainHook) error { + metaStorage := args.generalConfig.SmartContractsStorage + metaStorage.DB.FilePath = metaStorage.DB.FilePath + "_meta" + + vmFactoryMeta, err := createMetaVmContainerFactory( + args, argsHook, + ) if err != nil { - return nil, nil, err + return err } - accountsAdapterApi, err := createNewAccountsAdapterApi(args, apiBlockchain) + vmContainerMeta, err := vmFactoryMeta.Create() if err != nil { - return nil, nil, err + return err } - argsHook.BlockChain = apiBlockchain - argsHook.Accounts = accountsAdapterApi + vmMeta, err := vmContainerMeta.Get(factory2.SystemVirtualMachine) + if err != nil { + return err + } + + err = vmContainer.Add(factory2.SystemVirtualMachine, vmMeta) + if err != nil { + return err + } + + return nil +} +func createMetaVmContainerFactory(args *scQueryElementArgs, argsHook hooks.ArgBlockChainHook) (process.VirtualMachinesContainerFactory, error) { blockChainHookImpl, errBlockChainHook := hooks.NewBlockChainHookImpl(argsHook) if errBlockChainHook != nil { - return nil, nil, errBlockChainHook + return nil, errBlockChainHook } argsNewVmFactory := metachain.ArgsNewVMContainerFactory{ @@ -492,26 +529,20 @@ func createMetaVmContainerFactory(args *scQueryElementArgs, argsHook hooks.ArgBl ShardCoordinator: args.processComponents.ShardCoordinator(), EnableEpochsHandler: args.coreComponents.EnableEpochsHandler(), } + vmFactory, err := metachain.NewVMContainerFactory(argsNewVmFactory) if err != nil { - return nil, nil, err + return nil, err } - return apiBlockchain, vmFactory, nil + return vmFactory, nil } -func createShardVmContainerFactory(args *scQueryElementArgs, argsHook hooks.ArgBlockChainHook) (data.ChainHandler, process.VirtualMachinesContainerFactory, error) { - apiBlockchain, err := blockchain.NewBlockChain(disabled.NewAppStatusHandler()) - if err != nil { - return nil, nil, err - } - - accountsAdapterApi, err := createNewAccountsAdapterApi(args, apiBlockchain) +func createShardVmContainerFactory(args *scQueryElementArgs, argsHook hooks.ArgBlockChainHook) (state.AccountsAdapterAPI, process.VirtualMachinesContainerFactory, error) { + accountsAdapterApi, err := createNewAccountsAdapterApi(args, argsHook.BlockChain) if err != nil { return nil, nil, err } - - argsHook.BlockChain = apiBlockchain argsHook.Accounts = accountsAdapterApi queryVirtualMachineConfig := args.generalConfig.VirtualMachine.Querying.VirtualMachineConfig @@ -547,7 +578,7 @@ func createShardVmContainerFactory(args *scQueryElementArgs, argsHook hooks.ArgB return nil, nil, err } - return apiBlockchain, vmFactory, nil + return accountsAdapterApi, vmFactory, nil } func createNewAccountsAdapterApi(args *scQueryElementArgs, chainHandler data.ChainHandler) (state.AccountsAdapterAPI, error) { diff --git a/factory/api/apiResolverFactory_test.go b/factory/api/apiResolverFactory_test.go index 3c547b84b5b..94a37c0e843 100644 --- a/factory/api/apiResolverFactory_test.go +++ b/factory/api/apiResolverFactory_test.go @@ -108,7 +108,7 @@ func createMockArgs(t *testing.T) *api.ApiResolverArgs { StatusComponents: &mainFactoryMocks.StatusComponentsStub{ ManagedPeersMonitorField: &testscommon.ManagedPeersMonitorStub{}, }, - ChainRunType: common.ChainRunTypeRegular, + ChainRunType: common.ChainRunTypeRegular, } } From 0577850d610710b449ddc3482df451613bd2131b Mon Sep 17 00:00:00 2001 From: axenteoctavian Date: Mon, 8 Jan 2024 18:11:08 +0200 Subject: [PATCH 11/56] initSystemAccount new function --- .../process/sovereignGenesisBlockCreator.go | 19 +++++++++++++++++++ 1 file changed, 19 insertions(+) diff --git a/genesis/process/sovereignGenesisBlockCreator.go b/genesis/process/sovereignGenesisBlockCreator.go index ce24af1f0c3..b66cda053cd 100644 --- a/genesis/process/sovereignGenesisBlockCreator.go +++ b/genesis/process/sovereignGenesisBlockCreator.go @@ -52,9 +52,28 @@ func (gbc *sovereignGenesisBlockCreator) CreateGenesisBlocks() (map[uint32]data. return nil, err } + err = gbc.initSystemAccount() + if err != nil { + return nil, err + } + 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 { From 31ce7209e139ae137901afe69415cd57a9a181bd Mon Sep 17 00:00:00 2001 From: axenteoctavian Date: Tue, 9 Jan 2024 09:44:46 +0200 Subject: [PATCH 12/56] api resolver factory fix --- factory/api/apiResolverFactory.go | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/factory/api/apiResolverFactory.go b/factory/api/apiResolverFactory.go index 403d57360be..75dc667608e 100644 --- a/factory/api/apiResolverFactory.go +++ b/factory/api/apiResolverFactory.go @@ -419,11 +419,11 @@ func createScQueryElement( if args.processComponents.ShardCoordinator().SelfId() == core.MetachainShardId { maxGasForVmQueries = args.generalConfig.VirtualMachine.GasConfig.MetaMaxGasPerVmQuery - accountsAdapterApi, err := createNewAccountsAdapterApi(args, apiBlockchain) + accAdapter, err = createNewAccountsAdapterApi(args, apiBlockchain) if err != nil { return nil, err } - argsHook.Accounts = accountsAdapterApi + argsHook.Accounts = accAdapter vmFactory, err = createMetaVmContainerFactory(args, argsHook) } else { From c92999f327025c4f430be1b66ef057bda09c52b7 Mon Sep 17 00:00:00 2001 From: axenteoctavian Date: Tue, 9 Jan 2024 13:01:24 +0200 Subject: [PATCH 13/56] extract ArgsNewSCQueryService in a function to be able to test --- factory/api/apiResolverFactory.go | 37 +++++--- factory/api/apiResolverFactory_test.go | 126 +++++++++++++++++++++++++ factory/api/export_test.go | 23 +++++ 3 files changed, 171 insertions(+), 15 deletions(-) diff --git a/factory/api/apiResolverFactory.go b/factory/api/apiResolverFactory.go index 75dc667608e..e42499d5842 100644 --- a/factory/api/apiResolverFactory.go +++ b/factory/api/apiResolverFactory.go @@ -347,19 +347,28 @@ func createScQueryService( func createScQueryElement( args *scQueryElementArgs, ) (process.SCQueryService, error) { + argsNewSCQueryService, err := createArgsSCQueryService(args) + if err != nil { + return nil, err + } + + return smartContract.NewSCQueryService(argsNewSCQueryService) +} + +func createArgsSCQueryService(args *scQueryElementArgs) (smartContract.ArgsNewSCQueryService, error) { var err error pkConverter := args.coreComponents.AddressPubKeyConverter() automaticCrawlerAddressesStrings := args.generalConfig.BuiltInFunctions.AutomaticCrawlerAddresses convertedAddresses, errDecode := factory.DecodeAddresses(pkConverter, automaticCrawlerAddressesStrings) if errDecode != nil { - return nil, errDecode + return smartContract.ArgsNewSCQueryService{}, errDecode } dnsV2AddressesStrings := args.generalConfig.BuiltInFunctions.DNSV2Addresses convertedDNSV2Addresses, errDecode := factory.DecodeAddresses(pkConverter, dnsV2AddressesStrings) if errDecode != nil { - return nil, errDecode + return smartContract.ArgsNewSCQueryService{}, errDecode } builtInFuncFactory, err := createBuiltinFuncs( @@ -375,13 +384,13 @@ func createScQueryElement( convertedDNSV2Addresses, ) if err != nil { - return nil, err + return smartContract.ArgsNewSCQueryService{}, err } cacherCfg := storageFactory.GetCacherFromConfig(args.generalConfig.SmartContractDataPool) smartContractsCache, err := storageunit.NewCache(cacherCfg) if err != nil { - return nil, err + return smartContract.ArgsNewSCQueryService{}, err } scStorage := args.generalConfig.SmartContractsStorageForSCQuery @@ -409,7 +418,7 @@ func createScQueryElement( apiBlockchain, err := blockchain.NewMetaChain(disabled.NewAppStatusHandler()) if err != nil { - return nil, err + return smartContract.ArgsNewSCQueryService{}, err } argsHook.BlockChain = apiBlockchain @@ -421,7 +430,7 @@ func createScQueryElement( accAdapter, err = createNewAccountsAdapterApi(args, apiBlockchain) if err != nil { - return nil, err + return smartContract.ArgsNewSCQueryService{}, err } argsHook.Accounts = accAdapter @@ -431,33 +440,33 @@ func createScQueryElement( argsHook.Accounts = accAdapter } if err != nil { - return nil, err + return smartContract.ArgsNewSCQueryService{}, err } log.Debug("maximum gas per VM Query", "value", maxGasForVmQueries) vmContainer, err := vmFactory.Create() if err != nil { - return nil, err + return smartContract.ArgsNewSCQueryService{}, err } if args.chainRunType == common.ChainRunTypeSovereign { err = addSystemVMToContainer(args, vmContainer, argsHook) if err != nil { - return nil, err + return smartContract.ArgsNewSCQueryService{}, err } } err = vmFactory.BlockChainHookImpl().SetVMContainer(vmContainer) if err != nil { - return nil, err + return smartContract.ArgsNewSCQueryService{}, err } err = builtInFuncFactory.SetPayableHandler(vmFactory.BlockChainHookImpl()) if err != nil { - return nil, err + return smartContract.ArgsNewSCQueryService{}, err } - argsNewSCQueryService := smartContract.ArgsNewSCQueryService{ + return smartContract.ArgsNewSCQueryService{ VmContainer: vmContainer, EconomicsFee: args.coreComponents.EconomicsData(), BlockChainHook: vmFactory.BlockChainHookImpl(), @@ -473,9 +482,7 @@ func createScQueryElement( Marshaller: args.coreComponents.InternalMarshalizer(), Hasher: args.coreComponents.Hasher(), Uint64ByteSliceConverter: args.coreComponents.Uint64ByteSliceConverter(), - } - - return smartContract.NewSCQueryService(argsNewSCQueryService) + }, nil } func addSystemVMToContainer(args *scQueryElementArgs, vmContainer process.VirtualMachinesContainer, argsHook hooks.ArgBlockChainHook) error { diff --git a/factory/api/apiResolverFactory_test.go b/factory/api/apiResolverFactory_test.go index 94a37c0e843..f29674a06f7 100644 --- a/factory/api/apiResolverFactory_test.go +++ b/factory/api/apiResolverFactory_test.go @@ -1,6 +1,7 @@ package api_test import ( + "fmt" "strings" "sync" "testing" @@ -16,6 +17,7 @@ import ( "github.com/multiversx/mx-chain-go/factory/mock" testsMocks "github.com/multiversx/mx-chain-go/integrationTests/mock" "github.com/multiversx/mx-chain-go/process" + vmFactory "github.com/multiversx/mx-chain-go/process/factory" "github.com/multiversx/mx-chain-go/process/sync/disabled" "github.com/multiversx/mx-chain-go/state" "github.com/multiversx/mx-chain-go/testscommon" @@ -452,3 +454,127 @@ func TestCreateApiResolver_createScQueryElement(t *testing.T) { }) } + +func TestCreateApiResolver_createArgsSCQueryService(t *testing.T) { + t.Parallel() + + t.Run("sovereign should add systemVM", func(t *testing.T) { + t.Parallel() + args := createMockSCQueryElementArgs() + args.SystemSCConfig = &config.SystemSmartContractsConfig{ + ESDTSystemSCConfig: config.ESDTSystemSCConfig{ + BaseIssuingCost: "1000", + OwnerAddress: "erd1fpkcgel4gcmh8zqqdt043yfcn5tyx8373kg6q2qmkxzu4dqamc0swts65c", + }, + GovernanceSystemSCConfig: config.GovernanceSystemSCConfig{ + V1: config.GovernanceSystemSCConfigV1{ + ProposalCost: "500", + NumNodes: 100, + MinQuorum: 50, + MinPassThreshold: 50, + MinVetoThreshold: 50, + }, + Active: config.GovernanceSystemSCConfigActive{ + ProposalCost: "500", + MinQuorum: 0.5, + MinPassThreshold: 0.5, + MinVetoThreshold: 0.5, + }, + OwnerAddress: "erd1vxy22x0fj4zv6hktmydg8vpfh6euv02cz4yg0aaws6rrad5a5awqgqky80", + }, + StakingSystemSCConfig: config.StakingSystemSCConfig{ + GenesisNodePrice: "2500000000000000000000", + MinStakeValue: "1", + UnJailValue: "1", + MinStepValue: "1", + UnBondPeriod: 0, + NumRoundsWithoutBleed: 0, + MaximumPercentageToBleed: 0, + BleedPercentagePerRound: 0, + MaxNumberOfNodesForStake: 10, + ActivateBLSPubKeyMessageVerification: false, + MinUnstakeTokensValue: "1", + }, + DelegationManagerSystemSCConfig: config.DelegationManagerSystemSCConfig{ + MinCreationDeposit: "100", + MinStakeAmount: "100", + ConfigChangeAddress: "erd1vxy22x0fj4zv6hktmydg8vpfh6euv02cz4yg0aaws6rrad5a5awqgqky80", + }, + DelegationSystemSCConfig: config.DelegationSystemSCConfig{ + MinServiceFee: 0, + MaxServiceFee: 100, + }, + } + args.ChainRunType = common.ChainRunTypeSovereign + + argsScQueryService, err := api.CreateArgsSCQueryService(args) + require.Nil(t, err) + require.NotNil(t, argsScQueryService.VmContainer) + + require.Equal(t, 2, argsScQueryService.VmContainer.Len()) + + svm, err := argsScQueryService.VmContainer.Get(vmFactory.SystemVirtualMachine) + require.Nil(t, err) + require.NotNil(t, svm) + require.Equal(t, "*process.systemVM", fmt.Sprintf("%T", svm)) + }) + t.Run("shard should NOT add systemVM", func(t *testing.T) { + t.Parallel() + args := createMockSCQueryElementArgs() + args.SystemSCConfig = &config.SystemSmartContractsConfig{ + ESDTSystemSCConfig: config.ESDTSystemSCConfig{ + BaseIssuingCost: "1000", + OwnerAddress: "erd1fpkcgel4gcmh8zqqdt043yfcn5tyx8373kg6q2qmkxzu4dqamc0swts65c", + }, + GovernanceSystemSCConfig: config.GovernanceSystemSCConfig{ + V1: config.GovernanceSystemSCConfigV1{ + ProposalCost: "500", + NumNodes: 100, + MinQuorum: 50, + MinPassThreshold: 50, + MinVetoThreshold: 50, + }, + Active: config.GovernanceSystemSCConfigActive{ + ProposalCost: "500", + MinQuorum: 0.5, + MinPassThreshold: 0.5, + MinVetoThreshold: 0.5, + }, + OwnerAddress: "erd1vxy22x0fj4zv6hktmydg8vpfh6euv02cz4yg0aaws6rrad5a5awqgqky80", + }, + StakingSystemSCConfig: config.StakingSystemSCConfig{ + GenesisNodePrice: "2500000000000000000000", + MinStakeValue: "1", + UnJailValue: "1", + MinStepValue: "1", + UnBondPeriod: 0, + NumRoundsWithoutBleed: 0, + MaximumPercentageToBleed: 0, + BleedPercentagePerRound: 0, + MaxNumberOfNodesForStake: 10, + ActivateBLSPubKeyMessageVerification: false, + MinUnstakeTokensValue: "1", + }, + DelegationManagerSystemSCConfig: config.DelegationManagerSystemSCConfig{ + MinCreationDeposit: "100", + MinStakeAmount: "100", + ConfigChangeAddress: "erd1vxy22x0fj4zv6hktmydg8vpfh6euv02cz4yg0aaws6rrad5a5awqgqky80", + }, + DelegationSystemSCConfig: config.DelegationSystemSCConfig{ + MinServiceFee: 0, + MaxServiceFee: 100, + }, + } + args.ChainRunType = common.ChainRunTypeRegular + + argsScQueryService, err := api.CreateArgsSCQueryService(args) + require.Nil(t, err) + require.NotNil(t, argsScQueryService.VmContainer) + + require.Equal(t, 1, argsScQueryService.VmContainer.Len()) + + svm, err := argsScQueryService.VmContainer.Get(vmFactory.SystemVirtualMachine) + require.NotNil(t, err) + require.Nil(t, svm) + }) +} diff --git a/factory/api/export_test.go b/factory/api/export_test.go index b5bfb1d48f9..6e1197969eb 100644 --- a/factory/api/export_test.go +++ b/factory/api/export_test.go @@ -6,6 +6,7 @@ import ( "github.com/multiversx/mx-chain-go/config" "github.com/multiversx/mx-chain-go/factory" "github.com/multiversx/mx-chain-go/process" + "github.com/multiversx/mx-chain-go/process/smartContract" "github.com/multiversx/mx-chain-go/vm" ) @@ -50,3 +51,25 @@ func CreateScQueryElement(args SCQueryElementArgs) (process.SCQueryService, erro chainRunType: args.ChainRunType, }) } + +// CreateArgsSCQueryService - create the args for SC Query Service +func CreateArgsSCQueryService(args SCQueryElementArgs) (smartContract.ArgsNewSCQueryService, error) { + return createArgsSCQueryService(&scQueryElementArgs{ + generalConfig: args.GeneralConfig, + epochConfig: args.EpochConfig, + coreComponents: args.CoreComponents, + stateComponents: args.StateComponents, + dataComponents: args.DataComponents, + processComponents: args.ProcessComponents, + statusCoreComponents: args.StatusCoreComponents, + gasScheduleNotifier: args.GasScheduleNotifier, + messageSigVerifier: args.MessageSigVerifier, + systemSCConfig: args.SystemSCConfig, + bootstrapper: args.Bootstrapper, + allowVMQueriesChan: args.AllowVMQueriesChan, + workingDir: args.WorkingDir, + index: args.Index, + guardedAccountHandler: args.GuardedAccountHandler, + chainRunType: args.ChainRunType, + }) +} From 527096383b4dd8506e299b96c99d2cad2e54b17c Mon Sep 17 00:00:00 2001 From: axenteoctavian Date: Wed, 10 Jan 2024 11:38:21 +0200 Subject: [PATCH 14/56] fixes after review --- errors/errors.go | 3 + facade/errors.go | 3 - facade/nodeFacade.go | 9 +- facade/nodeFacade_test.go | 3 +- node/errors.go | 4 +- node/node.go | 3 - node/nodeFactory.go | 10 +- node/nodeHelper.go | 10 +- node/nodeHelper_test.go | 34 ++++ node/nodeRunner.go | 5 - node/node_test.go | 116 ++++++++++-- node/sovereignNode.go | 9 +- node/sovereignNodeFactory.go | 9 +- node/sovereignNode_test.go | 350 +++-------------------------------- 14 files changed, 193 insertions(+), 375 deletions(-) create mode 100644 node/nodeHelper_test.go diff --git a/errors/errors.go b/errors/errors.go index ebd67c27db9..5a923fd4b5f 100644 --- a/errors/errors.go +++ b/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") diff --git a/facade/errors.go b/facade/errors.go index 2085f474b94..1a7035f6cc9 100644 --- a/facade/errors.go +++ b/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") diff --git a/facade/nodeFacade.go b/facade/nodeFacade.go index 77ca17669a2..e2229cbd5c9 100644 --- a/facade/nodeFacade.go +++ b/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,8 @@ 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 +74,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 +165,8 @@ 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 diff --git a/facade/nodeFacade_test.go b/facade/nodeFacade_test.go index b2f069f673b..4e52c8141fe 100644 --- a/facade/nodeFacade_test.go +++ b/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" + globalErrors "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, globalErrors.ErrNilNode, err) }) t.Run("nil ApiResolver should error", func(t *testing.T) { t.Parallel() diff --git a/node/errors.go b/node/errors.go index 4e75430e15d..4d240ffc432 100644 --- a/node/errors.go +++ b/node/errors.go @@ -142,5 +142,5 @@ var ErrNilCreateTransactionArgs = errors.New("nil args for create transaction") // ErrNilNodeRunner signals that a nil node runner was provided var ErrNilNodeRunner = errors.New("nil node runner") -// ErrNilNode signals that a nil node was provided -var ErrNilNode = errors.New("nil node") +// ErrNilNodeFactory signals that a nil node factory was provided +var ErrNilNodeFactory = errors.New("nil node factory") diff --git a/node/node.go b/node/node.go index cbd82d109f5..a6730f4ef81 100644 --- a/node/node.go +++ b/node/node.go @@ -213,7 +213,6 @@ func (n *Node) GetAllIssuedESDTs(tokenType string, ctx context.Context) ([]strin return n.baseGetAllIssuedESDTs(tokenType, ctx) } -// baseGetAllIssuedESDTs returns all the issued esdt tokens func (n *Node) baseGetAllIssuedESDTs(tokenType string, ctx context.Context) ([]string, error) { userAccount, _, err := n.loadUserAccountHandlerByPubKey(vm.ESDTSCAddress, api.AccountQueryOptions{}) if err != nil { @@ -439,7 +438,6 @@ func (n *Node) GetESDTData(address, tokenID string, nonce uint64, options api.Ac return esdtToken, blockInfo, nil } -// getTokensIDsWithFilter returns token IDs based on filters, works only on metachain func (n *Node) getTokensIDsWithFilter( f filter, options api.AccountQueryOptions, @@ -452,7 +450,6 @@ func (n *Node) getTokensIDsWithFilter( return n.baseGetTokensIDsWithFilter(f, options, ctx) } -// baseGetTokensIDsWithFilter returns token IDs based on filters func (n *Node) baseGetTokensIDsWithFilter( f filter, options api.AccountQueryOptions, diff --git a/node/nodeFactory.go b/node/nodeFactory.go index f76910bfd8d..bf97e23b3c2 100644 --- a/node/nodeFactory.go +++ b/node/nodeFactory.go @@ -3,20 +3,14 @@ package node type nodeFactory struct { } -// NewNodeFactory creates a new node factory instance +// 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) { - n, err := NewNode(opts...) - - if err != nil { - return nil, err - } - - return n, nil + return NewNode(opts...) } // IsInterfaceNil checks if the underlying pointer is nil diff --git a/node/nodeHelper.go b/node/nodeHelper.go index ed75f3bbf35..0f7cda5a319 100644 --- a/node/nodeHelper.go +++ b/node/nodeHelper.go @@ -2,6 +2,7 @@ package node import ( "errors" + "github.com/multiversx/mx-chain-core-go/core/check" "time" "github.com/multiversx/mx-chain-core-go/core" @@ -55,10 +56,13 @@ func CreateNode( consensusComponents factory.ConsensusComponentsHandler, bootstrapRoundIndex uint64, isInImportMode bool, - factoryNode NodeFactory, + nodeFactory NodeFactory, extraOptions ...Option, - ) (NodeHandler, error) { + if check.IfNil(nodeFactory) { + return nil, ErrNilNodeFactory + } + prepareOpenTopics(networkComponents.InputAntiFloodHandler(), processComponents.ShardCoordinator()) peerDenialEvaluator, err := createAndAttachPeerDenialEvaluators(networkComponents, processComponents) @@ -103,7 +107,7 @@ func CreateNode( } options = append(options, extraOptions...) - nd, err = factoryNode.CreateNewNode(options...) + nd, err = nodeFactory.CreateNewNode(options...) if err != nil { return nil, errors.New("error creating node: " + err.Error()) } diff --git a/node/nodeHelper_test.go b/node/nodeHelper_test.go new file mode 100644 index 00000000000..f9ff1ba5d4d --- /dev/null +++ b/node/nodeHelper_test.go @@ -0,0 +1,34 @@ +package node_test + +import ( + "testing" + + "github.com/multiversx/mx-chain-go/config" + "github.com/multiversx/mx-chain-go/node" + "github.com/stretchr/testify/require" +) + +func TestCreateNode(t *testing.T) { + t.Parallel() + + nodeHandler, err := node.CreateNode( + &config.Config{}, + nil, + getDefaultBootstrapComponents(), + getDefaultCoreComponents(), + getDefaultCryptoComponents(), + getDefaultDataComponents(), + getDefaultNetworkComponents(), + getDefaultProcessComponents(), + getDefaultStateComponents(), + nil, + nil, + nil, + 0, + false, + nil) + + require.NotNil(t, err) + require.Equal(t, node.ErrNilNodeFactory, err) + require.Nil(t, nodeHandler) +} diff --git a/node/nodeRunner.go b/node/nodeRunner.go index d831e965e23..eb279bc3f3e 100644 --- a/node/nodeRunner.go +++ b/node/nodeRunner.go @@ -949,11 +949,6 @@ func (nr *nodeRunner) CreateManagedHeartbeatV2Components( return managedHeartbeatV2Components, nil } -//func (nr *nodeRunner) CreateNodeFactory() (NodeFactory, error) { -// nf := NewNodeFactory() -// return nf, nil -//} - func waitForSignal( sigs chan os.Signal, chanStopNodeProcess chan endProcess.ArgEndProcess, diff --git a/node/node_test.go b/node/node_test.go index 57e549fe2fe..188a0cc1a98 100644 --- a/node/node_test.go +++ b/node/node_test.go @@ -1150,9 +1150,7 @@ func TestNode_GetAllESDTTokensShouldReturnEsdtAndFormattedNft(t *testing.T) { assert.Equal(t, uint64(1), tokens[expectedNftFormattedKey].TokenMetaData.Nonce) } -func TestNode_GetAllIssuedESDTs(t *testing.T) { - t.Parallel() - +func testNodeGetAllIssuedESDTs(t *testing.T, nodeFactory node.NodeFactory, shardId uint32) { acc := createAcc([]byte("newaddress")) esdtToken := []byte("TCK-RANDOM") sftToken := []byte("SFT-RANDOM") @@ -1217,14 +1215,14 @@ func TestNode_GetAllIssuedESDTs(t *testing.T) { stateComponents.AccountsRepo, _ = state.NewAccountsRepository(args) processComponents := getDefaultProcessComponents() processComponents.ShardCoord = &mock.ShardCoordinatorMock{ - SelfShardId: core.MetachainShardId, + SelfShardId: shardId, } - n, _ := node.NewNode( + + n, _ := nodeFactory.CreateNewNode( node.WithCoreComponents(coreComponents), node.WithDataComponents(dataComponents), node.WithStateComponents(stateComponents), - node.WithProcessComponents(processComponents), - ) + node.WithProcessComponents(processComponents)) value, err := n.GetAllIssuedESDTs(core.FungibleESDT, context.Background()) assert.Nil(t, err) @@ -1246,9 +1244,28 @@ func TestNode_GetAllIssuedESDTs(t *testing.T) { assert.Equal(t, 3, len(value)) } -func TestNode_GetESDTsWithRole(t *testing.T) { +func TestNode_GetAllESDTTokens_ShouldWork(t *testing.T) { + t.Parallel() + + testNodeGetAllIssuedESDTs(t, node.NewNodeFactory(), core.MetachainShardId) +} + +func TestNode_GetAllESDTTokens_WrongChainId(t *testing.T) { t.Parallel() + processComponents := getDefaultProcessComponents() + processComponents.ShardCoord = &mock.ShardCoordinatorMock{ + SelfShardId: 0, + } + n, err := node.NewNode(node.WithProcessComponents(processComponents)) + require.Nil(t, err) + + value, err := n.GetAllIssuedESDTs("", context.Background()) + require.Nil(t, value) + require.Equal(t, node.ErrMetachainOnlyEndpoint, err) +} + +func testNodeGetESDTsWithRole(t *testing.T, nodeFactory node.NodeFactory, shardId uint32) { addrBytes := testscommon.TestPubKeyAlice acc := createAcc(addrBytes) esdtToken := []byte("TCK-RANDOM") @@ -1302,9 +1319,9 @@ func TestNode_GetESDTsWithRole(t *testing.T) { stateComponents.AccountsRepo, _ = state.NewAccountsRepository(args) processComponents := getDefaultProcessComponents() processComponents.ShardCoord = &mock.ShardCoordinatorMock{ - SelfShardId: core.MetachainShardId, + SelfShardId: shardId, } - n, _ := node.NewNode( + n, _ := nodeFactory.CreateNewNode( node.WithCoreComponents(coreComponents), node.WithDataComponents(dataComponents), node.WithStateComponents(stateComponents), @@ -1326,9 +1343,31 @@ func TestNode_GetESDTsWithRole(t *testing.T) { require.Len(t, tokenResult, 0) } -func TestNode_GetESDTsRoles(t *testing.T) { +func TestNode_GetESDTsWithRole_ShouldWork(t *testing.T) { t.Parallel() + testNodeGetESDTsWithRole(t, node.NewNodeFactory(), core.MetachainShardId) +} + +func TestNode_GetESDTsWithRole_WrongChainId(t *testing.T) { + t.Parallel() + + coreComponents := getDefaultCoreComponents() + processComponents := getDefaultProcessComponents() + processComponents.ShardCoord = &mock.ShardCoordinatorMock{ + SelfShardId: 0, + } + n, err := node.NewNode( + node.WithCoreComponents(coreComponents), + node.WithProcessComponents(processComponents)) + require.Nil(t, err) + + testResult, _, err := n.GetESDTsWithRole(testscommon.TestAddressAlice, core.ESDTRoleNFTCreate, api.AccountQueryOptions{}, context.Background()) + require.Nil(t, testResult) + require.Equal(t, node.ErrMetachainOnlyEndpoint, err) +} + +func testNodeGetESDTsRoles(t *testing.T, nodeFactory node.NodeFactory, shardId uint32) { addrBytes := testscommon.TestPubKeyAlice acc := createAcc(addrBytes) esdtToken := []byte("TCK-RANDOM") @@ -1381,9 +1420,9 @@ func TestNode_GetESDTsRoles(t *testing.T) { stateComponents.AccountsRepo, _ = state.NewAccountsRepository(args) processComponents := getDefaultProcessComponents() processComponents.ShardCoord = &mock.ShardCoordinatorMock{ - SelfShardId: core.MetachainShardId, + SelfShardId: shardId, } - n, _ := node.NewNode( + n, _ := nodeFactory.CreateNewNode( node.WithCoreComponents(coreComponents), node.WithDataComponents(dataComponents), node.WithStateComponents(stateComponents), @@ -1397,9 +1436,31 @@ func TestNode_GetESDTsRoles(t *testing.T) { }, tokenResult) } -func TestNode_GetNFTTokenIDsRegisteredByAddress(t *testing.T) { +func TestNode_GetESDTsRoles_ShouldWork(t *testing.T) { + t.Parallel() + + testNodeGetESDTsWithRole(t, node.NewNodeFactory(), core.MetachainShardId) +} + +func TestNode_GetESDTsRoles_WrongChainId(t *testing.T) { t.Parallel() + coreComponents := getDefaultCoreComponents() + processComponents := getDefaultProcessComponents() + processComponents.ShardCoord = &mock.ShardCoordinatorMock{ + SelfShardId: 0, + } + n, err := node.NewNode( + node.WithCoreComponents(coreComponents), + node.WithProcessComponents(processComponents)) + require.Nil(t, err) + + tokenResult, _, err := n.GetESDTsRoles(testscommon.TestAddressAlice, api.AccountQueryOptions{}, context.Background()) + require.Nil(t, tokenResult) + require.Equal(t, node.ErrMetachainOnlyEndpoint, err) +} + +func testNodeGetNFTTokenIDsRegisteredByAddress(t *testing.T, nodeFactory node.NodeFactory, shardId uint32) { addrBytes := testscommon.TestPubKeyAlice acc := createAcc(addrBytes) esdtToken := []byte("TCK-RANDOM") @@ -1447,9 +1508,9 @@ func TestNode_GetNFTTokenIDsRegisteredByAddress(t *testing.T) { stateComponents.AccountsRepo, _ = state.NewAccountsRepository(args) processComponents := getDefaultProcessComponents() processComponents.ShardCoord = &mock.ShardCoordinatorMock{ - SelfShardId: core.MetachainShardId, + SelfShardId: shardId, } - n, _ := node.NewNode( + n, _ := nodeFactory.CreateNewNode( node.WithCoreComponents(coreComponents), node.WithDataComponents(dataComponents), node.WithStateComponents(stateComponents), @@ -1462,6 +1523,29 @@ func TestNode_GetNFTTokenIDsRegisteredByAddress(t *testing.T) { require.Equal(t, string(esdtToken), tokenResult[0]) } +func TestNode_GetNFTTokenIDsRegisteredByAddress_ShouldWork(t *testing.T) { + t.Parallel() + + testNodeGetNFTTokenIDsRegisteredByAddress(t, node.NewNodeFactory(), core.MetachainShardId) +} + +func TestNode_GetNFTTokenIDsRegisteredByAddress_WrongChainId(t *testing.T) { + t.Parallel() + + coreComponents := getDefaultCoreComponents() + processComponents := getDefaultProcessComponents() + processComponents.ShardCoord = &mock.ShardCoordinatorMock{ + SelfShardId: 0, + } + n, err := node.NewNode( + node.WithCoreComponents(coreComponents), + node.WithProcessComponents(processComponents)) + + tokenResult, _, err := n.GetNFTTokenIDsRegisteredByAddress(testscommon.TestAddressAlice, api.AccountQueryOptions{}, context.Background()) + require.Nil(t, tokenResult) + require.Equal(t, node.ErrMetachainOnlyEndpoint, err) +} + func TestNode_GetNFTTokenIDsRegisteredByAddressContextShouldTimeout(t *testing.T) { t.Parallel() diff --git a/node/sovereignNode.go b/node/sovereignNode.go index c38fc71d90f..0896e6c5f1c 100644 --- a/node/sovereignNode.go +++ b/node/sovereignNode.go @@ -2,18 +2,21 @@ package node import ( "context" + "github.com/multiversx/mx-chain-core-go/core" + "github.com/multiversx/mx-chain-core-go/core/check" "github.com/multiversx/mx-chain-core-go/data/api" + "github.com/multiversx/mx-chain-go/errors" ) type sovereignNode struct { *Node } -// NewSovereignNode creates a new sovereignNode instance +// NewSovereignNode creates a new sovereign node instance func NewSovereignNode(node *Node) (*sovereignNode, error) { - if node == nil { - return nil, ErrNilNode + if check.IfNil(node) { + return nil, errors.ErrNilNode } return &sovereignNode{ diff --git a/node/sovereignNodeFactory.go b/node/sovereignNodeFactory.go index c0c485304bb..72c1a976240 100644 --- a/node/sovereignNodeFactory.go +++ b/node/sovereignNodeFactory.go @@ -8,19 +8,14 @@ func NewSovereignNodeFactory() *sovereignNodeFactory { return &sovereignNodeFactory{} } -// CreateNewNode will create a new NodeHandler +// CreateNewNode creates a new sovereign node func (snf *sovereignNodeFactory) CreateNewNode(opts ...Option) (NodeHandler, error) { nd, err := NewNode(opts...) if err != nil { return nil, err } - snd, err := NewSovereignNode(nd) - if err != nil { - return nil, err - } - - return snd, nil + return NewSovereignNode(nd) } // IsInterfaceNil checks if the underlying pointer is nil diff --git a/node/sovereignNode_test.go b/node/sovereignNode_test.go index 10721c44d56..28e1af357c5 100644 --- a/node/sovereignNode_test.go +++ b/node/sovereignNode_test.go @@ -1,354 +1,62 @@ package node_test import ( - "context" "testing" "github.com/multiversx/mx-chain-core-go/core" - "github.com/multiversx/mx-chain-core-go/data/api" - "github.com/multiversx/mx-chain-go/common" + "github.com/multiversx/mx-chain-go/errors" "github.com/multiversx/mx-chain-go/node" - "github.com/multiversx/mx-chain-go/node/mock" - "github.com/multiversx/mx-chain-go/state" - "github.com/multiversx/mx-chain-go/testscommon" - stateMock "github.com/multiversx/mx-chain-go/testscommon/state" - trieMock "github.com/multiversx/mx-chain-go/testscommon/trie" - "github.com/multiversx/mx-chain-go/vm/systemSmartContracts" - vmcommon "github.com/multiversx/mx-chain-vm-common-go" - "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" ) func TestNewSovereignNode(t *testing.T) { - n, err := node.NewNode() - require.Nil(t, err) - require.NotNil(t, n) - - sn, err := node.NewSovereignNode(n) - require.Nil(t, err) - require.NotNil(t, sn) -} - -func TestNewSovereignNode_NilNodeShouldError(t *testing.T) { t.Parallel() - _, err := node.NewSovereignNode(nil) - assert.NotNil(t, err) + t.Run("valid node should work", func(t *testing.T) { + t.Parallel() + + n, err := node.NewNode() + require.Nil(t, err) + require.NotNil(t, n) + + sn, err := node.NewSovereignNode(n) + require.Nil(t, err) + require.NotNil(t, sn) + }) + t.Run("nil node should error", func(t *testing.T) { + t.Parallel() + + sn, err := node.NewSovereignNode(nil) + require.NotNil(t, err) + require.Equal(t, errors.ErrNilNode, err) + require.Nil(t, sn) + }) } -func TestSovereignNode_GetAllIssuedESDTs(t *testing.T) { +func TestSovereignNode_GetAllESDTTokens_ShouldWork(t *testing.T) { t.Parallel() - acc := createAcc([]byte("newaddress")) - esdtToken := []byte("TCK-RANDOM") - sftToken := []byte("SFT-RANDOM") - nftToken := []byte("NFT-RANDOM") - - esdtData := &systemSmartContracts.ESDTDataV2{TokenName: []byte("fungible"), TokenType: []byte(core.FungibleESDT)} - marshalledData, _ := getMarshalizer().Marshal(esdtData) - _ = acc.SaveKeyValue(esdtToken, marshalledData) - - sftData := &systemSmartContracts.ESDTDataV2{TokenName: []byte("semi fungible"), TokenType: []byte(core.SemiFungibleESDT)} - sftMarshalledData, _ := getMarshalizer().Marshal(sftData) - _ = acc.SaveKeyValue(sftToken, sftMarshalledData) - - nftData := &systemSmartContracts.ESDTDataV2{TokenName: []byte("non fungible"), TokenType: []byte(core.NonFungibleESDT)} - nftMarshalledData, _ := getMarshalizer().Marshal(nftData) - _ = acc.SaveKeyValue(nftToken, nftMarshalledData) - - esdtSuffix := append(esdtToken, acc.AddressBytes()...) - nftSuffix := append(nftToken, acc.AddressBytes()...) - sftSuffix := append(sftToken, acc.AddressBytes()...) - - acc.SetDataTrie( - &trieMock.TrieStub{ - GetAllLeavesOnChannelCalled: func(leavesChannels *common.TrieIteratorChannels, ctx context.Context, rootHash []byte, _ common.KeyBuilder, tlp common.TrieLeafParser) error { - go func() { - trieLeaf, _ := tlp.ParseLeaf(esdtToken, append(marshalledData, esdtSuffix...), core.NotSpecified) - leavesChannels.LeavesChan <- trieLeaf - - trieLeaf, _ = tlp.ParseLeaf(sftToken, append(sftMarshalledData, sftSuffix...), core.NotSpecified) - leavesChannels.LeavesChan <- trieLeaf - - trieLeaf, _ = tlp.ParseLeaf(nftToken, append(nftMarshalledData, nftSuffix...), core.NotSpecified) - leavesChannels.LeavesChan <- trieLeaf - close(leavesChannels.LeavesChan) - leavesChannels.ErrChan.Close() - }() - - return nil - }, - RootCalled: func() ([]byte, error) { - return nil, nil - }, - }) - - accDB := &stateMock.AccountsStub{ - RecreateTrieCalled: func(rootHash []byte) error { - return nil - }, - } - accDB.GetAccountWithBlockInfoCalled = func(address []byte, options common.RootHashHolder) (vmcommon.AccountHandler, common.BlockInfo, error) { - return acc, nil, nil - } - - coreComponents := getDefaultCoreComponents() - dataComponents := getDefaultDataComponents() - stateComponents := getDefaultStateComponents() - args := state.ArgsAccountsRepository{ - FinalStateAccountsWrapper: accDB, - CurrentStateAccountsWrapper: accDB, - HistoricalStateAccountsWrapper: accDB, - } - stateComponents.AccountsRepo, _ = state.NewAccountsRepository(args) - processComponents := getDefaultProcessComponents() - processComponents.ShardCoord = &mock.ShardCoordinatorMock{ - SelfShardId: core.MetachainShardId, - } - - n, _ := node.NewNode( - node.WithCoreComponents(coreComponents), - node.WithDataComponents(dataComponents), - node.WithStateComponents(stateComponents), - node.WithProcessComponents(processComponents), - ) - sn, _ := node.NewSovereignNode(n) - - value, err := sn.GetAllIssuedESDTs(core.FungibleESDT, context.Background()) - assert.Nil(t, err) - assert.Equal(t, 1, len(value)) - assert.Equal(t, string(esdtToken), value[0]) - - value, err = sn.GetAllIssuedESDTs(core.SemiFungibleESDT, context.Background()) - assert.Nil(t, err) - assert.Equal(t, 1, len(value)) - assert.Equal(t, string(sftToken), value[0]) - - value, err = sn.GetAllIssuedESDTs(core.NonFungibleESDT, context.Background()) - assert.Nil(t, err) - assert.Equal(t, 1, len(value)) - assert.Equal(t, string(nftToken), value[0]) - - value, err = sn.GetAllIssuedESDTs("", context.Background()) - assert.Nil(t, err) - assert.Equal(t, 3, len(value)) + testNodeGetAllIssuedESDTs(t, node.NewSovereignNodeFactory(), core.SovereignChainShardId) + testNodeGetAllIssuedESDTs(t, node.NewSovereignNodeFactory(), core.MainChainShardId) } func TestSovereignNode_GetNFTTokenIDsRegisteredByAddress(t *testing.T) { t.Parallel() - addrBytes := testscommon.TestPubKeyAlice - acc := createAcc(addrBytes) - esdtToken := []byte("TCK-RANDOM") - - esdtData := &systemSmartContracts.ESDTDataV2{TokenName: []byte("fungible"), TokenType: []byte(core.SemiFungibleESDT), OwnerAddress: addrBytes} - marshalledData, _ := getMarshalizer().Marshal(esdtData) - _ = acc.SaveKeyValue(esdtToken, marshalledData) - - esdtSuffix := append(esdtToken, acc.AddressBytes()...) - - acc.SetDataTrie( - &trieMock.TrieStub{ - GetAllLeavesOnChannelCalled: func(leavesChannels *common.TrieIteratorChannels, ctx context.Context, rootHash []byte, _ common.KeyBuilder, tlp common.TrieLeafParser) error { - go func() { - trieLeaf, _ := tlp.ParseLeaf(esdtToken, append(marshalledData, esdtSuffix...), core.NotSpecified) - leavesChannels.LeavesChan <- trieLeaf - close(leavesChannels.LeavesChan) - leavesChannels.ErrChan.Close() - }() - - return nil - }, - RootCalled: func() ([]byte, error) { - return nil, nil - }, - }, - ) - - accDB := &stateMock.AccountsStub{ - RecreateTrieCalled: func(rootHash []byte) error { - return nil - }, - } - accDB.GetAccountWithBlockInfoCalled = func(address []byte, options common.RootHashHolder) (vmcommon.AccountHandler, common.BlockInfo, error) { - return acc, nil, nil - } - coreComponents := getDefaultCoreComponents() - stateComponents := getDefaultStateComponents() - dataComponents := getDefaultDataComponents() - args := state.ArgsAccountsRepository{ - FinalStateAccountsWrapper: accDB, - CurrentStateAccountsWrapper: accDB, - HistoricalStateAccountsWrapper: accDB, - } - stateComponents.AccountsRepo, _ = state.NewAccountsRepository(args) - processComponents := getDefaultProcessComponents() - processComponents.ShardCoord = &mock.ShardCoordinatorMock{ - SelfShardId: core.MetachainShardId, - } - n, _ := node.NewNode( - node.WithCoreComponents(coreComponents), - node.WithDataComponents(dataComponents), - node.WithStateComponents(stateComponents), - node.WithProcessComponents(processComponents), - ) - sn, _ := node.NewSovereignNode(n) - - tokenResult, _, err := sn.GetNFTTokenIDsRegisteredByAddress(testscommon.TestAddressAlice, api.AccountQueryOptions{}, context.Background()) - require.NoError(t, err) - require.Equal(t, 1, len(tokenResult)) - require.Equal(t, string(esdtToken), tokenResult[0]) + testNodeGetNFTTokenIDsRegisteredByAddress(t, node.NewSovereignNodeFactory(), core.SovereignChainShardId) + testNodeGetNFTTokenIDsRegisteredByAddress(t, node.NewSovereignNodeFactory(), core.MainChainShardId) } func TestSovereignNode_GetESDTsWithRole(t *testing.T) { t.Parallel() - addrBytes := testscommon.TestPubKeyAlice - acc := createAcc(addrBytes) - esdtToken := []byte("TCK-RANDOM") - - specialRoles := []*systemSmartContracts.ESDTRoles{ - { - Address: addrBytes, - Roles: [][]byte{[]byte(core.ESDTRoleNFTAddQuantity), []byte(core.ESDTRoleLocalMint)}, - }, - } - - esdtData := &systemSmartContracts.ESDTDataV2{TokenName: []byte("fungible"), TokenType: []byte(core.FungibleESDT), SpecialRoles: specialRoles} - marshalledData, _ := getMarshalizer().Marshal(esdtData) - _ = acc.SaveKeyValue(esdtToken, marshalledData) - - esdtSuffix := append(esdtToken, acc.AddressBytes()...) - - acc.SetDataTrie( - &trieMock.TrieStub{ - GetAllLeavesOnChannelCalled: func(leavesChannels *common.TrieIteratorChannels, ctx context.Context, rootHash []byte, _ common.KeyBuilder, tlp common.TrieLeafParser) error { - go func() { - trieLeaf, _ := tlp.ParseLeaf(esdtToken, append(marshalledData, esdtSuffix...), core.NotSpecified) - leavesChannels.LeavesChan <- trieLeaf - close(leavesChannels.LeavesChan) - leavesChannels.ErrChan.Close() - }() - - return nil - }, - RootCalled: func() ([]byte, error) { - return nil, nil - }, - }) - - accDB := &stateMock.AccountsStub{ - RecreateTrieCalled: func(rootHash []byte) error { - return nil - }, - } - accDB.GetAccountWithBlockInfoCalled = func(address []byte, options common.RootHashHolder) (vmcommon.AccountHandler, common.BlockInfo, error) { - return acc, nil, nil - } - coreComponents := getDefaultCoreComponents() - dataComponents := getDefaultDataComponents() - stateComponents := getDefaultStateComponents() - args := state.ArgsAccountsRepository{ - FinalStateAccountsWrapper: accDB, - CurrentStateAccountsWrapper: accDB, - HistoricalStateAccountsWrapper: accDB, - } - stateComponents.AccountsRepo, _ = state.NewAccountsRepository(args) - processComponents := getDefaultProcessComponents() - processComponents.ShardCoord = &mock.ShardCoordinatorMock{ - SelfShardId: core.MetachainShardId, - } - n, _ := node.NewNode( - node.WithCoreComponents(coreComponents), - node.WithDataComponents(dataComponents), - node.WithStateComponents(stateComponents), - node.WithProcessComponents(processComponents), - ) - sn, _ := node.NewSovereignNode(n) - - tokenResult, _, err := sn.GetESDTsWithRole(testscommon.TestAddressAlice, core.ESDTRoleNFTAddQuantity, api.AccountQueryOptions{}, context.Background()) - require.NoError(t, err) - require.Equal(t, 1, len(tokenResult)) - require.Equal(t, string(esdtToken), tokenResult[0]) - - tokenResult, _, err = sn.GetESDTsWithRole(testscommon.TestAddressAlice, core.ESDTRoleLocalMint, api.AccountQueryOptions{}, context.Background()) - require.NoError(t, err) - require.Equal(t, 1, len(tokenResult)) - require.Equal(t, string(esdtToken), tokenResult[0]) - - tokenResult, _, err = sn.GetESDTsWithRole(testscommon.TestAddressAlice, core.ESDTRoleNFTCreate, api.AccountQueryOptions{}, context.Background()) - require.NoError(t, err) - require.Len(t, tokenResult, 0) + testNodeGetESDTsWithRole(t, node.NewSovereignNodeFactory(), core.SovereignChainShardId) + testNodeGetESDTsWithRole(t, node.NewSovereignNodeFactory(), core.MainChainShardId) } func TestSovereignNode_GetESDTsRoles(t *testing.T) { t.Parallel() - addrBytes := testscommon.TestPubKeyAlice - acc := createAcc(addrBytes) - esdtToken := []byte("TCK-RANDOM") - - specialRoles := []*systemSmartContracts.ESDTRoles{ - { - Address: addrBytes, - Roles: [][]byte{[]byte(core.ESDTRoleNFTAddQuantity), []byte(core.ESDTRoleLocalMint)}, - }, - } - - esdtData := &systemSmartContracts.ESDTDataV2{TokenName: []byte("fungible"), TokenType: []byte(core.FungibleESDT), SpecialRoles: specialRoles} - marshalledData, _ := getMarshalizer().Marshal(esdtData) - - esdtSuffix := append(esdtToken, acc.AddressBytes()...) - - acc.SetDataTrie( - &trieMock.TrieStub{ - GetAllLeavesOnChannelCalled: func(leavesChannels *common.TrieIteratorChannels, ctx context.Context, rootHash []byte, _ common.KeyBuilder, tlp common.TrieLeafParser) error { - go func() { - trieLeaf, _ := tlp.ParseLeaf(esdtToken, append(marshalledData, esdtSuffix...), core.NotSpecified) - leavesChannels.LeavesChan <- trieLeaf - close(leavesChannels.LeavesChan) - leavesChannels.ErrChan.Close() - }() - - return nil - }, - RootCalled: func() ([]byte, error) { - return nil, nil - }, - }) - - accDB := &stateMock.AccountsStub{ - RecreateTrieCalled: func(rootHash []byte) error { - return nil - }, - } - accDB.GetAccountWithBlockInfoCalled = func(address []byte, options common.RootHashHolder) (vmcommon.AccountHandler, common.BlockInfo, error) { - return acc, nil, nil - } - coreComponents := getDefaultCoreComponents() - stateComponents := getDefaultStateComponents() - dataComponents := getDefaultDataComponents() - args := state.ArgsAccountsRepository{ - FinalStateAccountsWrapper: accDB, - CurrentStateAccountsWrapper: accDB, - HistoricalStateAccountsWrapper: accDB, - } - stateComponents.AccountsRepo, _ = state.NewAccountsRepository(args) - processComponents := getDefaultProcessComponents() - processComponents.ShardCoord = &mock.ShardCoordinatorMock{ - SelfShardId: core.MetachainShardId, - } - n, _ := node.NewNode( - node.WithCoreComponents(coreComponents), - node.WithDataComponents(dataComponents), - node.WithStateComponents(stateComponents), - node.WithProcessComponents(processComponents), - ) - sn, _ := node.NewSovereignNode(n) - - tokenResult, _, err := sn.GetESDTsRoles(testscommon.TestAddressAlice, api.AccountQueryOptions{}, context.Background()) - require.NoError(t, err) - require.Equal(t, map[string][]string{ - string(esdtToken): {core.ESDTRoleNFTAddQuantity, core.ESDTRoleLocalMint}, - }, tokenResult) + testNodeGetESDTsRoles(t, node.NewSovereignNodeFactory(), core.SovereignChainShardId) + testNodeGetESDTsRoles(t, node.NewSovereignNodeFactory(), core.MainChainShardId) } From c5edf5b1311e0a8c106798491be4650b32bc1aea Mon Sep 17 00:00:00 2001 From: axenteoctavian Date: Wed, 10 Jan 2024 11:43:15 +0200 Subject: [PATCH 15/56] fixes after review --- node/errors.go | 3 --- node/nodeHelper.go | 3 ++- node/nodeHelper_test.go | 3 ++- node/node_test.go | 3 ++- 4 files changed, 6 insertions(+), 6 deletions(-) diff --git a/node/errors.go b/node/errors.go index 4d240ffc432..69e0d5c0d69 100644 --- a/node/errors.go +++ b/node/errors.go @@ -141,6 +141,3 @@ var ErrNilCreateTransactionArgs = errors.New("nil args for create transaction") // ErrNilNodeRunner signals that a nil node runner was provided var ErrNilNodeRunner = errors.New("nil node runner") - -// ErrNilNodeFactory signals that a nil node factory was provided -var ErrNilNodeFactory = errors.New("nil node factory") diff --git a/node/nodeHelper.go b/node/nodeHelper.go index 0f7cda5a319..9d59f2255a0 100644 --- a/node/nodeHelper.go +++ b/node/nodeHelper.go @@ -8,6 +8,7 @@ import ( "github.com/multiversx/mx-chain-core-go/core" "github.com/multiversx/mx-chain-go/common" "github.com/multiversx/mx-chain-go/config" + globalErrors "github.com/multiversx/mx-chain-go/errors" "github.com/multiversx/mx-chain-go/factory" "github.com/multiversx/mx-chain-go/node/nodeDebugFactory" "github.com/multiversx/mx-chain-go/p2p" @@ -60,7 +61,7 @@ func CreateNode( extraOptions ...Option, ) (NodeHandler, error) { if check.IfNil(nodeFactory) { - return nil, ErrNilNodeFactory + return nil, globalErrors.ErrNilNode } prepareOpenTopics(networkComponents.InputAntiFloodHandler(), processComponents.ShardCoordinator()) diff --git a/node/nodeHelper_test.go b/node/nodeHelper_test.go index f9ff1ba5d4d..43f613cf0db 100644 --- a/node/nodeHelper_test.go +++ b/node/nodeHelper_test.go @@ -4,6 +4,7 @@ import ( "testing" "github.com/multiversx/mx-chain-go/config" + "github.com/multiversx/mx-chain-go/errors" "github.com/multiversx/mx-chain-go/node" "github.com/stretchr/testify/require" ) @@ -29,6 +30,6 @@ func TestCreateNode(t *testing.T) { nil) require.NotNil(t, err) - require.Equal(t, node.ErrNilNodeFactory, err) + require.Equal(t, errors.ErrNilNode, err) require.Nil(t, nodeHandler) } diff --git a/node/node_test.go b/node/node_test.go index 188a0cc1a98..7e4304a81c6 100644 --- a/node/node_test.go +++ b/node/node_test.go @@ -1222,7 +1222,8 @@ func testNodeGetAllIssuedESDTs(t *testing.T, nodeFactory node.NodeFactory, shard node.WithCoreComponents(coreComponents), node.WithDataComponents(dataComponents), node.WithStateComponents(stateComponents), - node.WithProcessComponents(processComponents)) + node.WithProcessComponents(processComponents), + ) value, err := n.GetAllIssuedESDTs(core.FungibleESDT, context.Background()) assert.Nil(t, err) From f407a827d9d6fdf268a3d1b18d9f4e0303a4471e Mon Sep 17 00:00:00 2001 From: axenteoctavian Date: Wed, 10 Jan 2024 11:45:30 +0200 Subject: [PATCH 16/56] fixes after review --- node/nodeHelper.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/node/nodeHelper.go b/node/nodeHelper.go index 9d59f2255a0..e5b7fde1891 100644 --- a/node/nodeHelper.go +++ b/node/nodeHelper.go @@ -2,10 +2,10 @@ package node import ( "errors" - "github.com/multiversx/mx-chain-core-go/core/check" "time" "github.com/multiversx/mx-chain-core-go/core" + "github.com/multiversx/mx-chain-core-go/core/check" "github.com/multiversx/mx-chain-go/common" "github.com/multiversx/mx-chain-go/config" globalErrors "github.com/multiversx/mx-chain-go/errors" From 9c2feb1ca57eb63586613b51091a733ac31ee408 Mon Sep 17 00:00:00 2001 From: axenteoctavian Date: Wed, 10 Jan 2024 13:05:37 +0200 Subject: [PATCH 17/56] fixes after review --- cmd/sovereignnode/sovereignNodeRunner.go | 30 ++++++------- factory/api/apiResolverFactory.go | 44 +++++++++---------- factory/api/apiResolverFactory_test.go | 26 +++++++++-- factory/errors.go | 8 ++-- node/nodeRunner.go | 32 +++++++------- .../factory/delegatedListHandlerFactory.go | 14 +++--- .../delegatedListHandlerFactory_test.go | 17 ++++--- .../factory/directStakedListHandlerFactory.go | 14 +++--- .../directStakedListHandlerFactory_test.go | 17 ++++--- node/trieIterators/factory/interface.go | 10 +++-- .../sovereignDelegatedListHandlerFactory.go | 14 +++--- ...vereignDelegatedListHandlerFactory_test.go | 7 ++- ...sovereignDirectStakedListHandlerFactory.go | 8 ++-- ...eignDirectStakedListHandlerFactory_test.go | 7 ++- 14 files changed, 133 insertions(+), 115 deletions(-) diff --git a/cmd/sovereignnode/sovereignNodeRunner.go b/cmd/sovereignnode/sovereignNodeRunner.go index bc4ff97e12b..efa1c607d71 100644 --- a/cmd/sovereignnode/sovereignNodeRunner.go +++ b/cmd/sovereignnode/sovereignNodeRunner.go @@ -679,21 +679,21 @@ func (snr *sovereignNodeRunner) createApiFacade( log.Debug("creating api resolver structure") 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(), - GasScheduleNotifier: gasScheduleNotifier, - Bootstrapper: currentNode.GetConsensusComponents().Bootstrapper(), - AllowVMQueriesChan: allowVMQueriesChan, - StatusComponents: currentNode.GetStatusComponents(), - ChainRunType: common.ChainRunTypeSovereign, - DelegatedListHandler: trieIteratorsFactory.NewSovereignDelegatedListHandlerFactory(), - DirectStakedListHandler: trieIteratorsFactory.NewSovereignDirectStakedListHandlerFactory(), + Configs: configs.Configs, + CoreComponents: currentNode.GetCoreComponents(), + DataComponents: currentNode.GetDataComponents(), + StateComponents: currentNode.GetStateComponents(), + BootstrapComponents: currentNode.GetBootstrapComponents(), + CryptoComponents: currentNode.GetCryptoComponents(), + ProcessComponents: currentNode.GetProcessComponents(), + StatusCoreComponents: currentNode.GetStatusCoreComponents(), + GasScheduleNotifier: gasScheduleNotifier, + Bootstrapper: currentNode.GetConsensusComponents().Bootstrapper(), + AllowVMQueriesChan: allowVMQueriesChan, + StatusComponents: currentNode.GetStatusComponents(), + ChainRunType: common.ChainRunTypeSovereign, + DelegatedListFactoryHandler: trieIteratorsFactory.NewSovereignDelegatedListProcessorFactory(), + DirectStakedListFactoryHandler: trieIteratorsFactory.NewSovereignDirectStakedListProcessorFactory(), } apiResolver, err := apiComp.CreateApiResolver(apiResolverArgs) diff --git a/factory/api/apiResolverFactory.go b/factory/api/apiResolverFactory.go index af42de00ed3..56651fb3b4c 100644 --- a/factory/api/apiResolverFactory.go +++ b/factory/api/apiResolverFactory.go @@ -56,22 +56,22 @@ var log = logger.GetOrCreate("factory") // ApiResolverArgs holds the argument needed to create an API resolver type ApiResolverArgs struct { - Configs *config.Configs - CoreComponents factory.CoreComponentsHolder - DataComponents factory.DataComponentsHolder - StateComponents factory.StateComponentsHolder - BootstrapComponents factory.BootstrapComponentsHolder - CryptoComponents factory.CryptoComponentsHolder - ProcessComponents factory.ProcessComponentsHolder - StatusCoreComponents factory.StatusCoreComponentsHolder - StatusComponents factory.StatusComponentsHolder - GasScheduleNotifier common.GasScheduleNotifierAPI - Bootstrapper process.Bootstrapper - AllowVMQueriesChan chan struct{} - ProcessingMode common.NodeProcessingMode - ChainRunType common.ChainRunType - DelegatedListHandler trieIteratorsFactory.DelegatedListHandler - DirectStakedListHandler trieIteratorsFactory.DirectStakedListHandler + Configs *config.Configs + CoreComponents factory.CoreComponentsHolder + DataComponents factory.DataComponentsHolder + StateComponents factory.StateComponentsHolder + BootstrapComponents factory.BootstrapComponentsHolder + CryptoComponents factory.CryptoComponentsHolder + ProcessComponents factory.ProcessComponentsHolder + StatusCoreComponents factory.StatusCoreComponentsHolder + StatusComponents factory.StatusComponentsHolder + GasScheduleNotifier common.GasScheduleNotifierAPI + Bootstrapper process.Bootstrapper + AllowVMQueriesChan chan struct{} + ProcessingMode common.NodeProcessingMode + ChainRunType common.ChainRunType + DelegatedListFactoryHandler trieIteratorsFactory.DelegatedListProcessorFactoryHandler + DirectStakedListFactoryHandler trieIteratorsFactory.DirectStakedListProcessorFactoryHandler } type scQueryServiceArgs struct { @@ -118,11 +118,11 @@ type scQueryElementArgs struct { func CreateApiResolver(args *ApiResolverArgs) (facade.ApiResolver, error) { apiWorkingDir := filepath.Join(args.Configs.FlagsConfig.WorkingDir, common.TemporaryPath) - if check.IfNilReflect(args.DelegatedListHandler) { - return nil, factory.ErrorNilDelegatedListHandler + if check.IfNilReflect(args.DelegatedListFactoryHandler) { + return nil, factory.ErrNilDelegatedListFactory } - if check.IfNilReflect(args.DirectStakedListHandler) { - return nil, factory.ErrorNilDirectStakedListHandler + if check.IfNilReflect(args.DirectStakedListFactoryHandler) { + return nil, factory.ErrNilDirectStakedListFactory } argsSCQuery := &scQueryServiceArgs{ @@ -212,12 +212,12 @@ func CreateApiResolver(args *ApiResolverArgs) (facade.ApiResolver, error) { return nil, err } - directStakedListHandler, err := args.DirectStakedListHandler.CreateDirectStakedListHandler(argsProcessors) + directStakedListHandler, err := args.DirectStakedListFactoryHandler.CreateDirectStakedListProcessorHandler(argsProcessors) if err != nil { return nil, err } - delegatedListHandler, err := args.DelegatedListHandler.CreateDelegatedListHandler(argsProcessors) + delegatedListHandler, err := args.DelegatedListFactoryHandler.CreateDelegatedListProcessorHandler(argsProcessors) if err != nil { return nil, err } diff --git a/factory/api/apiResolverFactory_test.go b/factory/api/apiResolverFactory_test.go index 80783ae8217..39aa4ba3783 100644 --- a/factory/api/apiResolverFactory_test.go +++ b/factory/api/apiResolverFactory_test.go @@ -11,6 +11,7 @@ import ( "github.com/multiversx/mx-chain-core-go/marshal" "github.com/multiversx/mx-chain-go/common" "github.com/multiversx/mx-chain-go/config" + factoryErrors "github.com/multiversx/mx-chain-go/factory" "github.com/multiversx/mx-chain-go/factory/api" "github.com/multiversx/mx-chain-go/factory/bootstrap" "github.com/multiversx/mx-chain-go/factory/mock" @@ -109,9 +110,9 @@ func createMockArgs(t *testing.T) *api.ApiResolverArgs { StatusComponents: &mainFactoryMocks.StatusComponentsStub{ ManagedPeersMonitorField: &testscommon.ManagedPeersMonitorStub{}, }, - ChainRunType: common.ChainRunTypeRegular, - DelegatedListHandler: trieIteratorsFactory.NewDelegatedListHandlerFactory(), - DirectStakedListHandler: trieIteratorsFactory.NewDirectStakedListHandlerFactory(), + ChainRunType: common.ChainRunTypeRegular, + DelegatedListFactoryHandler: trieIteratorsFactory.NewDelegatedListProcessorFactory(), + DirectStakedListFactoryHandler: trieIteratorsFactory.NewDirectStakedListProcessorFactory(), } } @@ -286,6 +287,25 @@ func TestCreateApiResolver(t *testing.T) { require.Nil(t, err) require.False(t, check.IfNil(apiResolver)) }) + + t.Run("DelegatedListFactoryHandler nil should error", func(t *testing.T) { + t.Parallel() + + args := createMockArgs(t) + args.DelegatedListFactoryHandler = nil + apiResolver, err := api.CreateApiResolver(args) + require.Equal(t, factoryErrors.ErrNilDelegatedListFactory, err) + require.True(t, check.IfNil(apiResolver)) + }) + t.Run("DirectStakedListFactoryHandler nil should error", func(t *testing.T) { + t.Parallel() + + args := createMockArgs(t) + args.DirectStakedListFactoryHandler = nil + apiResolver, err := api.CreateApiResolver(args) + require.Equal(t, factoryErrors.ErrNilDirectStakedListFactory, err) + require.True(t, check.IfNil(apiResolver)) + }) } func createMockSCQueryElementArgs() api.SCQueryElementArgs { diff --git a/factory/errors.go b/factory/errors.go index e74065f89f1..dc1e3aa6adb 100644 --- a/factory/errors.go +++ b/factory/errors.go @@ -2,8 +2,8 @@ package factory import "errors" -// ErrorNilDelegatedListHandler signal that returned account is wrong -var ErrorNilDelegatedListHandler = errors.New("nil DelegatedListHandler") +// ErrNilDelegatedListFactory signal that a nil delegated list handler factory has been provided +var ErrNilDelegatedListFactory = errors.New("nil delegated list factory has been provided") -// ErrorNilDirectStakedListHandler signal that returned account is wrong -var ErrorNilDirectStakedListHandler = errors.New("nil DirectStakedListHandler") +// ErrNilDirectStakedListFactory signal that a nil direct staked list handler factory has been provided +var ErrNilDirectStakedListFactory = errors.New("nil direct staked list factory has been provided") diff --git a/node/nodeRunner.go b/node/nodeRunner.go index 67990ac1532..4f594f22993 100644 --- a/node/nodeRunner.go +++ b/node/nodeRunner.go @@ -707,22 +707,22 @@ func (nr *nodeRunner) createApiFacade( log.Debug("creating api resolver structure") apiResolverArgs := &apiComp.ApiResolverArgs{ - Configs: configs, - CoreComponents: currentNode.coreComponents, - DataComponents: currentNode.dataComponents, - StateComponents: currentNode.stateComponents, - BootstrapComponents: currentNode.bootstrapComponents, - CryptoComponents: currentNode.cryptoComponents, - ProcessComponents: currentNode.processComponents, - StatusCoreComponents: currentNode.statusCoreComponents, - GasScheduleNotifier: gasScheduleNotifier, - Bootstrapper: currentNode.consensusComponents.Bootstrapper(), - AllowVMQueriesChan: allowVMQueriesChan, - StatusComponents: currentNode.statusComponents, - ProcessingMode: common.GetNodeProcessingMode(nr.configs.ImportDbConfig), - ChainRunType: common.ChainRunTypeRegular, - DelegatedListHandler: trieIteratorsFactory.NewDelegatedListHandlerFactory(), - DirectStakedListHandler: trieIteratorsFactory.NewDirectStakedListHandlerFactory(), + Configs: configs, + CoreComponents: currentNode.coreComponents, + DataComponents: currentNode.dataComponents, + StateComponents: currentNode.stateComponents, + BootstrapComponents: currentNode.bootstrapComponents, + CryptoComponents: currentNode.cryptoComponents, + ProcessComponents: currentNode.processComponents, + StatusCoreComponents: currentNode.statusCoreComponents, + GasScheduleNotifier: gasScheduleNotifier, + Bootstrapper: currentNode.consensusComponents.Bootstrapper(), + AllowVMQueriesChan: allowVMQueriesChan, + StatusComponents: currentNode.statusComponents, + ProcessingMode: common.GetNodeProcessingMode(nr.configs.ImportDbConfig), + ChainRunType: common.ChainRunTypeRegular, + DelegatedListFactoryHandler: trieIteratorsFactory.NewDelegatedListProcessorFactory(), + DirectStakedListFactoryHandler: trieIteratorsFactory.NewDirectStakedListProcessorFactory(), } apiResolver, err := apiComp.CreateApiResolver(apiResolverArgs) diff --git a/node/trieIterators/factory/delegatedListHandlerFactory.go b/node/trieIterators/factory/delegatedListHandlerFactory.go index 6b39592c109..c331399ce34 100644 --- a/node/trieIterators/factory/delegatedListHandlerFactory.go +++ b/node/trieIterators/factory/delegatedListHandlerFactory.go @@ -7,16 +7,16 @@ import ( "github.com/multiversx/mx-chain-go/node/trieIterators/disabled" ) -type delegatedListHandlerFactory struct { +type delegatedListProcessorFactory struct { } -// NewDelegatedListHandlerFactory create a new delegated list handler -func NewDelegatedListHandlerFactory() *delegatedListHandlerFactory { - return &delegatedListHandlerFactory{} +// NewDelegatedListProcessorFactory create a new delegated list handler +func NewDelegatedListProcessorFactory() *delegatedListProcessorFactory { + return &delegatedListProcessorFactory{} } -// CreateDelegatedListHandler will create a new instance of DirectStakedListHandler -func (d *delegatedListHandlerFactory) CreateDelegatedListHandler(args trieIterators.ArgTrieIteratorProcessor) (external.DelegatedListHandler, error) { +// CreateDelegatedListProcessorHandler will create a new instance of delegated list processor for regular/normal chain +func (d *delegatedListProcessorFactory) CreateDelegatedListProcessorHandler(args trieIterators.ArgTrieIteratorProcessor) (external.DelegatedListHandler, error) { if args.ShardID != core.MetachainShardId { return disabled.NewDisabledDelegatedListProcessor(), nil } @@ -25,6 +25,6 @@ func (d *delegatedListHandlerFactory) CreateDelegatedListHandler(args trieIterat } // IsInterfaceNil checks if the underlying pointer is nil -func (d *delegatedListHandlerFactory) IsInterfaceNil() bool { +func (d *delegatedListProcessorFactory) IsInterfaceNil() bool { return d == nil } diff --git a/node/trieIterators/factory/delegatedListHandlerFactory_test.go b/node/trieIterators/factory/delegatedListHandlerFactory_test.go index 6330d7f09ea..5264b2bbe52 100644 --- a/node/trieIterators/factory/delegatedListHandlerFactory_test.go +++ b/node/trieIterators/factory/delegatedListHandlerFactory_test.go @@ -11,30 +11,29 @@ import ( trieIteratorsFactory "github.com/multiversx/mx-chain-go/node/trieIterators/factory" "github.com/multiversx/mx-chain-go/testscommon" stateMock "github.com/multiversx/mx-chain-go/testscommon/state" - "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" ) -func TestNewDelegatedListHandlerFactory(t *testing.T) { +func TestNewDelegatedListProcessorFactory(t *testing.T) { t.Parallel() - delegatedListHandlerFactory := trieIteratorsFactory.NewDelegatedListHandlerFactory() + delegatedListHandlerFactory := trieIteratorsFactory.NewDelegatedListProcessorFactory() require.False(t, delegatedListHandlerFactory.IsInterfaceNil()) } -func TestDelegatedListHandlerFactory_CreateDelegatedListHandler_Disabled(t *testing.T) { +func TestDelegatedListProcessorFactory_CreateDelegatedListProcessorHandler_Disabled(t *testing.T) { t.Parallel() args := trieIterators.ArgTrieIteratorProcessor{ ShardID: 0, } - delegatedListHandler, err := trieIteratorsFactory.NewDelegatedListHandlerFactory().CreateDelegatedListHandler(args) + delegatedListHandler, err := trieIteratorsFactory.NewDelegatedListProcessorFactory().CreateDelegatedListProcessorHandler(args) require.Nil(t, err) - assert.Equal(t, "*disabled.delegatedListProcessor", fmt.Sprintf("%T", delegatedListHandler)) + require.Equal(t, "*disabled.delegatedListProcessor", fmt.Sprintf("%T", delegatedListHandler)) } -func TestDelegatedListHandlerFactory_CreateDelegatedListHandler_DelegatedListProcessor(t *testing.T) { +func TestDelegatedListProcessorFactory_CreateDelegatedListProcessorHandler_DelegatedListProcessorFactory(t *testing.T) { t.Parallel() args := trieIterators.ArgTrieIteratorProcessor{ @@ -47,7 +46,7 @@ func TestDelegatedListHandlerFactory_CreateDelegatedListHandler_DelegatedListPro QueryService: &mock.SCQueryServiceStub{}, } - delegatedListHandler, err := trieIteratorsFactory.NewDelegatedListHandlerFactory().CreateDelegatedListHandler(args) + delegatedListHandler, err := trieIteratorsFactory.NewDelegatedListProcessorFactory().CreateDelegatedListProcessorHandler(args) require.Nil(t, err) - assert.Equal(t, "*trieIterators.delegatedListProcessor", fmt.Sprintf("%T", delegatedListHandler)) + require.Equal(t, "*trieIterators.delegatedListProcessor", fmt.Sprintf("%T", delegatedListHandler)) } diff --git a/node/trieIterators/factory/directStakedListHandlerFactory.go b/node/trieIterators/factory/directStakedListHandlerFactory.go index 7d26a152315..63dd52c2c3d 100644 --- a/node/trieIterators/factory/directStakedListHandlerFactory.go +++ b/node/trieIterators/factory/directStakedListHandlerFactory.go @@ -7,16 +7,16 @@ import ( "github.com/multiversx/mx-chain-go/node/trieIterators/disabled" ) -type directStakedListHandlerFactory struct { +type directStakedListProcessorFactory struct { } -// NewDirectStakedListHandlerFactory create a new direct staked list handler -func NewDirectStakedListHandlerFactory() *directStakedListHandlerFactory { - return &directStakedListHandlerFactory{} +// NewDirectStakedListProcessorFactory create a new direct staked list handler +func NewDirectStakedListProcessorFactory() *directStakedListProcessorFactory { + return &directStakedListProcessorFactory{} } -// CreateDirectStakedListHandler will create a new instance of DirectStakedListHandler -func (ds *directStakedListHandlerFactory) CreateDirectStakedListHandler(args trieIterators.ArgTrieIteratorProcessor) (external.DirectStakedListHandler, error) { +// CreateDirectStakedListProcessorHandler will create a new instance of direct staked list processor for regular/normal chain +func (ds *directStakedListProcessorFactory) CreateDirectStakedListProcessorHandler(args trieIterators.ArgTrieIteratorProcessor) (external.DirectStakedListHandler, error) { if args.ShardID != core.MetachainShardId { return disabled.NewDisabledDirectStakedListProcessor(), nil } @@ -25,6 +25,6 @@ func (ds *directStakedListHandlerFactory) CreateDirectStakedListHandler(args tri } // IsInterfaceNil checks if the underlying pointer is nil -func (ds *directStakedListHandlerFactory) IsInterfaceNil() bool { +func (ds *directStakedListProcessorFactory) IsInterfaceNil() bool { return ds == nil } diff --git a/node/trieIterators/factory/directStakedListHandlerFactory_test.go b/node/trieIterators/factory/directStakedListHandlerFactory_test.go index 29912682189..38b660b18f9 100644 --- a/node/trieIterators/factory/directStakedListHandlerFactory_test.go +++ b/node/trieIterators/factory/directStakedListHandlerFactory_test.go @@ -11,30 +11,29 @@ import ( trieIteratorsFactory "github.com/multiversx/mx-chain-go/node/trieIterators/factory" "github.com/multiversx/mx-chain-go/testscommon" stateMock "github.com/multiversx/mx-chain-go/testscommon/state" - "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" ) -func TestNewDirectStakedListHandlerFactory(t *testing.T) { +func TestNewDirectStakedListProcessorFactory(t *testing.T) { t.Parallel() - directStakedListHandlerFactory := trieIteratorsFactory.NewDirectStakedListHandlerFactory() + directStakedListHandlerFactory := trieIteratorsFactory.NewDirectStakedListProcessorFactory() require.False(t, directStakedListHandlerFactory.IsInterfaceNil()) } -func TestDirectStakedListHandlerFactory_CreateDirectStakedListHandler_Disabled(t *testing.T) { +func TestDirectStakedListProcessorFactory_CreateDirectStakedListProcessor_Disabled(t *testing.T) { t.Parallel() args := trieIterators.ArgTrieIteratorProcessor{ ShardID: 0, } - directStakedListHandler, err := trieIteratorsFactory.NewDirectStakedListHandlerFactory().CreateDirectStakedListHandler(args) + directStakedListHandler, err := trieIteratorsFactory.NewDirectStakedListProcessorFactory().CreateDirectStakedListProcessorHandler(args) require.Nil(t, err) - assert.Equal(t, "*disabled.directStakedListProcessor", fmt.Sprintf("%T", directStakedListHandler)) + require.Equal(t, "*disabled.directStakedListProcessor", fmt.Sprintf("%T", directStakedListHandler)) } -func TestDirectStakedListHandlerFactory_CreateDirectStakedListHandler_DirectStakedListProcessor(t *testing.T) { +func TestDirectStakedListProcessorFactory_CreateDirectStakedListProcessor_DirectStakedListProcessorFactory(t *testing.T) { t.Parallel() args := trieIterators.ArgTrieIteratorProcessor{ @@ -47,7 +46,7 @@ func TestDirectStakedListHandlerFactory_CreateDirectStakedListHandler_DirectStak QueryService: &mock.SCQueryServiceStub{}, } - directStakedListHandler, err := trieIteratorsFactory.NewDirectStakedListHandlerFactory().CreateDirectStakedListHandler(args) + directStakedListHandler, err := trieIteratorsFactory.NewDirectStakedListProcessorFactory().CreateDirectStakedListProcessorHandler(args) require.Nil(t, err) - assert.Equal(t, "*trieIterators.directStakedListProcessor", fmt.Sprintf("%T", directStakedListHandler)) + require.Equal(t, "*trieIterators.directStakedListProcessor", fmt.Sprintf("%T", directStakedListHandler)) } diff --git a/node/trieIterators/factory/interface.go b/node/trieIterators/factory/interface.go index 636b55a3779..0488f64289b 100644 --- a/node/trieIterators/factory/interface.go +++ b/node/trieIterators/factory/interface.go @@ -5,12 +5,14 @@ import ( "github.com/multiversx/mx-chain-go/node/trieIterators" ) -type DelegatedListHandler interface { - CreateDelegatedListHandler(args trieIterators.ArgTrieIteratorProcessor) (external.DelegatedListHandler, error) +// DelegatedListProcessorFactoryHandler can create delegated list processor handler +type DelegatedListProcessorFactoryHandler interface { + CreateDelegatedListProcessorHandler(args trieIterators.ArgTrieIteratorProcessor) (external.DelegatedListHandler, error) IsInterfaceNil() bool } -type DirectStakedListHandler interface { - CreateDirectStakedListHandler(args trieIterators.ArgTrieIteratorProcessor) (external.DirectStakedListHandler, error) +// DirectStakedListProcessorFactoryHandler can create direct staked list processor handler +type DirectStakedListProcessorFactoryHandler interface { + CreateDirectStakedListProcessorHandler(args trieIterators.ArgTrieIteratorProcessor) (external.DirectStakedListHandler, error) IsInterfaceNil() bool } diff --git a/node/trieIterators/factory/sovereignDelegatedListHandlerFactory.go b/node/trieIterators/factory/sovereignDelegatedListHandlerFactory.go index 7b8f52dbbbb..5332c323101 100644 --- a/node/trieIterators/factory/sovereignDelegatedListHandlerFactory.go +++ b/node/trieIterators/factory/sovereignDelegatedListHandlerFactory.go @@ -5,20 +5,20 @@ import ( "github.com/multiversx/mx-chain-go/node/trieIterators" ) -type sovereignDelegatedListHandlerFactory struct { +type sovereignDelegatedListProcessorFactory struct { } -// NewSovereignDelegatedListHandlerFactory create a new sovereign delegated list handler -func NewSovereignDelegatedListHandlerFactory() *sovereignDelegatedListHandlerFactory { - return &sovereignDelegatedListHandlerFactory{} +// NewSovereignDelegatedListProcessorFactory creates a new sovereign delegated list handler +func NewSovereignDelegatedListProcessorFactory() *sovereignDelegatedListProcessorFactory { + return &sovereignDelegatedListProcessorFactory{} } -// CreateDelegatedListHandler will create a new instance of DirectStakedListHandler -func (sd *sovereignDelegatedListHandlerFactory) CreateDelegatedListHandler(args trieIterators.ArgTrieIteratorProcessor) (external.DelegatedListHandler, error) { +// CreateDelegatedListProcessorHandler creates a new instance of DirectStakedListHandler +func (sd *sovereignDelegatedListProcessorFactory) CreateDelegatedListProcessorHandler(args trieIterators.ArgTrieIteratorProcessor) (external.DelegatedListHandler, error) { return trieIterators.NewDelegatedListProcessor(args) } // IsInterfaceNil checks if the underlying pointer is nil -func (sd *sovereignDelegatedListHandlerFactory) IsInterfaceNil() bool { +func (sd *sovereignDelegatedListProcessorFactory) IsInterfaceNil() bool { return sd == nil } diff --git a/node/trieIterators/factory/sovereignDelegatedListHandlerFactory_test.go b/node/trieIterators/factory/sovereignDelegatedListHandlerFactory_test.go index d842966748c..3e282ddbf7c 100644 --- a/node/trieIterators/factory/sovereignDelegatedListHandlerFactory_test.go +++ b/node/trieIterators/factory/sovereignDelegatedListHandlerFactory_test.go @@ -11,14 +11,13 @@ import ( trieIteratorsFactory "github.com/multiversx/mx-chain-go/node/trieIterators/factory" "github.com/multiversx/mx-chain-go/testscommon" stateMock "github.com/multiversx/mx-chain-go/testscommon/state" - "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" ) func TestNewSovereignDelegatedListHandlerFactory(t *testing.T) { t.Parallel() - sovereignDelegatedListHandlerFactory := trieIteratorsFactory.NewSovereignDelegatedListHandlerFactory() + sovereignDelegatedListHandlerFactory := trieIteratorsFactory.NewSovereignDelegatedListProcessorFactory() require.False(t, sovereignDelegatedListHandlerFactory.IsInterfaceNil()) } @@ -35,7 +34,7 @@ func TestSovereignDelegatedListHandlerFactory_CreateDelegatedListHandler_Delegat QueryService: &mock.SCQueryServiceStub{}, } - sovereignDelegatedListHandler, err := trieIteratorsFactory.NewSovereignDelegatedListHandlerFactory().CreateDelegatedListHandler(args) + sovereignDelegatedListHandler, err := trieIteratorsFactory.NewSovereignDelegatedListProcessorFactory().CreateDelegatedListProcessorHandler(args) require.Nil(t, err) - assert.Equal(t, "*trieIterators.delegatedListProcessor", fmt.Sprintf("%T", sovereignDelegatedListHandler)) + require.Equal(t, "*trieIterators.delegatedListProcessor", fmt.Sprintf("%T", sovereignDelegatedListHandler)) } diff --git a/node/trieIterators/factory/sovereignDirectStakedListHandlerFactory.go b/node/trieIterators/factory/sovereignDirectStakedListHandlerFactory.go index b9b236d6872..72c611d526d 100644 --- a/node/trieIterators/factory/sovereignDirectStakedListHandlerFactory.go +++ b/node/trieIterators/factory/sovereignDirectStakedListHandlerFactory.go @@ -8,13 +8,13 @@ import ( type sovereignDirectStakedListHandlerFactory struct { } -// NewSovereignDirectStakedListHandlerFactory create a new sovereign direct staked list handler -func NewSovereignDirectStakedListHandlerFactory() *sovereignDirectStakedListHandlerFactory { +// NewSovereignDirectStakedListProcessorFactory creates a new sovereign direct staked list handler +func NewSovereignDirectStakedListProcessorFactory() *sovereignDirectStakedListHandlerFactory { return &sovereignDirectStakedListHandlerFactory{} } -// CreateDirectStakedListHandler will create a new instance of DirectStakedListHandler -func (ds *sovereignDirectStakedListHandlerFactory) CreateDirectStakedListHandler(args trieIterators.ArgTrieIteratorProcessor) (external.DirectStakedListHandler, error) { +// CreateDirectStakedListProcessorHandler creates a new instance of DirectStakedListHandler +func (ds *sovereignDirectStakedListHandlerFactory) CreateDirectStakedListProcessorHandler(args trieIterators.ArgTrieIteratorProcessor) (external.DirectStakedListHandler, error) { return trieIterators.NewDirectStakedListProcessor(args) } diff --git a/node/trieIterators/factory/sovereignDirectStakedListHandlerFactory_test.go b/node/trieIterators/factory/sovereignDirectStakedListHandlerFactory_test.go index f53e8ca819e..7326cd09e13 100644 --- a/node/trieIterators/factory/sovereignDirectStakedListHandlerFactory_test.go +++ b/node/trieIterators/factory/sovereignDirectStakedListHandlerFactory_test.go @@ -11,14 +11,13 @@ import ( trieIteratorsFactory "github.com/multiversx/mx-chain-go/node/trieIterators/factory" "github.com/multiversx/mx-chain-go/testscommon" stateMock "github.com/multiversx/mx-chain-go/testscommon/state" - "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" ) func TestNewSovereignDirectStakedListHandlerFactory(t *testing.T) { t.Parallel() - directStakedListHandlerFactory := trieIteratorsFactory.NewDirectStakedListHandlerFactory() + directStakedListHandlerFactory := trieIteratorsFactory.NewSovereignDirectStakedListProcessorFactory() require.False(t, directStakedListHandlerFactory.IsInterfaceNil()) } @@ -35,7 +34,7 @@ func TestSovereignDirectStakedListHandlerFactory_CreateDirectStakedListHandler_D QueryService: &mock.SCQueryServiceStub{}, } - sovereignDirectStakedListHandler, err := trieIteratorsFactory.NewSovereignDirectStakedListHandlerFactory().CreateDirectStakedListHandler(args) + sovereignDirectStakedListHandler, err := trieIteratorsFactory.NewSovereignDirectStakedListProcessorFactory().CreateDirectStakedListProcessorHandler(args) require.Nil(t, err) - assert.Equal(t, "*trieIterators.directStakedListProcessor", fmt.Sprintf("%T", sovereignDirectStakedListHandler)) + require.Equal(t, "*trieIterators.directStakedListProcessor", fmt.Sprintf("%T", sovereignDirectStakedListHandler)) } From 29efba7dc8c06a290b52e51f92d4d0e6d040fb91 Mon Sep 17 00:00:00 2001 From: axenteoctavian Date: Wed, 10 Jan 2024 13:09:12 +0200 Subject: [PATCH 18/56] fix golangci linter --- node/node_test.go | 1 + 1 file changed, 1 insertion(+) diff --git a/node/node_test.go b/node/node_test.go index 7e4304a81c6..ad39ed412b5 100644 --- a/node/node_test.go +++ b/node/node_test.go @@ -1541,6 +1541,7 @@ func TestNode_GetNFTTokenIDsRegisteredByAddress_WrongChainId(t *testing.T) { n, err := node.NewNode( node.WithCoreComponents(coreComponents), node.WithProcessComponents(processComponents)) + require.Nil(t, err) tokenResult, _, err := n.GetNFTTokenIDsRegisteredByAddress(testscommon.TestAddressAlice, api.AccountQueryOptions{}, context.Background()) require.Nil(t, tokenResult) From 68c3fbcb09febdaf5a14b9ff6d9ca8cd723d19b4 Mon Sep 17 00:00:00 2001 From: axenteoctavian Date: Wed, 10 Jan 2024 13:12:14 +0200 Subject: [PATCH 19/56] fix test --- integrationTests/testProcessorNodeWithTestWebServer.go | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/integrationTests/testProcessorNodeWithTestWebServer.go b/integrationTests/testProcessorNodeWithTestWebServer.go index e9c54afc005..89b5d57d462 100644 --- a/integrationTests/testProcessorNodeWithTestWebServer.go +++ b/integrationTests/testProcessorNodeWithTestWebServer.go @@ -212,10 +212,10 @@ func createFacadeComponents(tpn *TestProcessorNode) nodeFacade.ApiResolver { totalStakedValueHandler, err := factory.CreateTotalStakedValueHandler(args) log.LogIfError(err) - directStakedListHandler, err := factory.NewDirectStakedListHandlerFactory().CreateDirectStakedListHandler(args) + directStakedListHandler, err := factory.NewDirectStakedListProcessorFactory().CreateDirectStakedListProcessorHandler(args) log.LogIfError(err) - delegatedListHandler, err := factory.NewDelegatedListHandlerFactory().CreateDelegatedListHandler(args) + delegatedListHandler, err := factory.NewDelegatedListProcessorFactory().CreateDelegatedListProcessorHandler(args) log.LogIfError(err) logsFacade := &testscommon.LogsFacadeStub{} From a927e136e4b9f3c1c02e4a8c284d55424ea6e7c7 Mon Sep 17 00:00:00 2001 From: axenteoctavian Date: Wed, 10 Jan 2024 13:31:30 +0200 Subject: [PATCH 20/56] test name fixes --- .../factory/sovereignDelegatedListHandlerFactory_test.go | 4 ++-- .../factory/sovereignDirectStakedListHandlerFactory_test.go | 4 ++-- 2 files changed, 4 insertions(+), 4 deletions(-) diff --git a/node/trieIterators/factory/sovereignDelegatedListHandlerFactory_test.go b/node/trieIterators/factory/sovereignDelegatedListHandlerFactory_test.go index 3e282ddbf7c..fdcff6c7866 100644 --- a/node/trieIterators/factory/sovereignDelegatedListHandlerFactory_test.go +++ b/node/trieIterators/factory/sovereignDelegatedListHandlerFactory_test.go @@ -14,14 +14,14 @@ import ( "github.com/stretchr/testify/require" ) -func TestNewSovereignDelegatedListHandlerFactory(t *testing.T) { +func TestNewSovereignDelegatedListProcessorFactory(t *testing.T) { t.Parallel() sovereignDelegatedListHandlerFactory := trieIteratorsFactory.NewSovereignDelegatedListProcessorFactory() require.False(t, sovereignDelegatedListHandlerFactory.IsInterfaceNil()) } -func TestSovereignDelegatedListHandlerFactory_CreateDelegatedListHandler_DelegatedListProcessor(t *testing.T) { +func TestSovereignDelegatedListProcessorFactory_CreateDelegatedListProcessorHandler_DelegatedListProcessorFactory(t *testing.T) { t.Parallel() args := trieIterators.ArgTrieIteratorProcessor{ diff --git a/node/trieIterators/factory/sovereignDirectStakedListHandlerFactory_test.go b/node/trieIterators/factory/sovereignDirectStakedListHandlerFactory_test.go index 7326cd09e13..de4cc13a9d7 100644 --- a/node/trieIterators/factory/sovereignDirectStakedListHandlerFactory_test.go +++ b/node/trieIterators/factory/sovereignDirectStakedListHandlerFactory_test.go @@ -14,14 +14,14 @@ import ( "github.com/stretchr/testify/require" ) -func TestNewSovereignDirectStakedListHandlerFactory(t *testing.T) { +func TestNewSovereignDirectStakedListProcessorFactory(t *testing.T) { t.Parallel() directStakedListHandlerFactory := trieIteratorsFactory.NewSovereignDirectStakedListProcessorFactory() require.False(t, directStakedListHandlerFactory.IsInterfaceNil()) } -func TestSovereignDirectStakedListHandlerFactory_CreateDirectStakedListHandler_DirectStakedListProcessor(t *testing.T) { +func TestSovereignDirectStakedListHandlerFactory_CreateDirectStakedListProcessorHandler_DirectStakedListHandlerFactory(t *testing.T) { t.Parallel() args := trieIterators.ArgTrieIteratorProcessor{ From d43e4e3fd5d1dd381c5b49d5535be706d99b4b2d Mon Sep 17 00:00:00 2001 From: axenteoctavian Date: Wed, 10 Jan 2024 15:55:38 +0200 Subject: [PATCH 21/56] fixes after review --- .../sovereignGenesisBlockCreator_test.go | 36 +++++++++++++++++++ 1 file changed, 36 insertions(+) diff --git a/genesis/process/sovereignGenesisBlockCreator_test.go b/genesis/process/sovereignGenesisBlockCreator_test.go index b17143d8a45..f9f32f7594f 100644 --- a/genesis/process/sovereignGenesisBlockCreator_test.go +++ b/genesis/process/sovereignGenesisBlockCreator_test.go @@ -158,3 +158,39 @@ 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"} + + loadAccountWasCalled := false + saveAccountWasCalled := false + var systemAccountLoaded []byte + accountsAdapter := &state.AccountsStub{ + LoadAccountCalled: func(address []byte) (vmcommon.AccountHandler, error) { + loadAccountWasCalled = true + if systemAccountLoaded == nil { // first loaded account saved (from initSystemAccount) + systemAccountLoaded = address + } + return state.NewAccountWrapMock(address), nil + }, + SaveAccountCalled: func(account vmcommon.AccountHandler) error { + saveAccountWasCalled = true + return nil + }, + } + arg.Accounts = accountsAdapter + + gbc, _ := NewGenesisBlockCreator(arg) + sgbc, _ := NewSovereignGenesisBlockCreator(gbc) + _, err := sgbc.CreateGenesisBlocks() + require.NotNil(t, err) + + require.NotNil(t, sgbc) + require.True(t, loadAccountWasCalled) + require.True(t, saveAccountWasCalled) + require.Equal(t, systemAccountLoaded, core.SystemAccountAddress) +} From f8cfc5882600286870a01412505f5454931c386b Mon Sep 17 00:00:00 2001 From: axenteoctavian Date: Thu, 11 Jan 2024 12:29:20 +0200 Subject: [PATCH 22/56] scripting files updates for sovereign --- scripts/testnet/config.sh | 14 +++++- scripts/testnet/deploySovereignScreen.sh | 36 +++++++++++++++ scripts/testnet/include/config.sh | 59 +++++++++++++++++++++++- scripts/testnet/txgen-basic.sh | 2 +- scripts/testnet/txgen-erc20.sh | 2 +- scripts/testnet/txgen-esdt.sh | 2 +- scripts/testnet/variables.sh | 14 +++--- 7 files changed, 117 insertions(+), 12 deletions(-) create mode 100644 scripts/testnet/deploySovereignScreen.sh diff --git a/scripts/testnet/config.sh b/scripts/testnet/config.sh index 41463ba533e..2425b708ec8 100755 --- a/scripts/testnet/config.sh +++ b/scripts/testnet/config.sh @@ -28,13 +28,23 @@ updateNodeConfig if [ $USE_PROXY -eq 1 ]; then prepareFolders_Proxy copyProxyConfig - updateProxyConfig + + if [ $SOVEREIGN_DEPLOY -eq 1 ]; then + updateSovereignProxyConfig + else + updateProxyConfig + fi fi if [ $USE_TXGEN -eq 1 ]; then prepareFolders_TxGen copyTxGenConfig - updateTxGenConfig + + if [ $SOVEREIGN_DEPLOY -eq 1 ]; then + updateSovereignTxGenConfig + else + updateTxGenConfig + fi fi if [ $USE_HARDFORK -eq 1 ]; then diff --git a/scripts/testnet/deploySovereignScreen.sh b/scripts/testnet/deploySovereignScreen.sh new file mode 100644 index 00000000000..a5ea123df4c --- /dev/null +++ b/scripts/testnet/deploySovereignScreen.sh @@ -0,0 +1,36 @@ +#!/usr/bin/env bash + +GREEN='\x1B[0;32m' +NC='\x1B[0m' + +echo -e "${GREEN}Making sure any previous deployment is stopped...${NC}" +./stop.sh + +echo -e "${GREEN}Cleaning the previous deployment (if any)...${NC}" +./clean.sh + +echo -e "${GREEN}Adjusting some variables.sh parameters...${NC}" +sed -i 's/export USE_TXGEN=[01]/export USE_TXGEN=1/' variables.sh +sed -i 's/export USE_PROXY=[01]/export USE_PROXY=1/' variables.sh +sed -i 's/export USE_ELASTICSEARCH=[01]/export USE_ELASTICSEARCH=1/' variables.sh +sed -i 's/export SOVEREIGN_DEPLOY=[01]/export SOVEREIGN_DEPLOY=1/' variables.sh + +echo -e "${GREEN}Generating the configuration files...${NC}" +./config.sh + +echo -e "${GREEN}Starting the sovereign chain (in a screen)...${NC}" +screen -L -Logfile sovereignStartLog.txt -d -m -S sovereignStartScreen ./sovereignStart.sh debug + +echo -e "${GREEN}Sleeping few minutes so the sovereign chain will begin...${NC}" +sleep 120 + +echo -e "${GREEN}Starting sending the basic scenario transactions...${NC}" +screen -L -Logfile txgenBasicLog.txt -d -m -S txgenBasicScreen ./sovereign-txgen-basic.sh + +echo -e "${GREEN}Starting sending the erc20 scenario transactions...${NC}" +screen -L -Logfile txgenErc20Log.txt -d -m -S txgenErc20Screen ./sovereign-txgen-erc20.sh + +echo -e "${GREEN}Starting sending the esdt scenario transactions...${NC}" +screen -L -Logfile txgenEsdtLog.txt -d -m -S txgenEsdtScreen ./sovereign-txgen-esdt.sh + +echo -e "${GREEN}Finished the sovereign chain deployment. Don't forget to stop it with ./stop.sh at the end.${NC}" \ No newline at end of file diff --git a/scripts/testnet/include/config.sh b/scripts/testnet/include/config.sh index 95abcf1571b..e36ac037afa 100644 --- a/scripts/testnet/include/config.sh +++ b/scripts/testnet/include/config.sh @@ -8,7 +8,12 @@ generateConfig() { TMP_META_OBSERVERCOUNT=0 fi + SOVEREIGN_BOOL="false" + if [ $USE_HARDFORK -eq 1 ]; then + SOVEREIGN_BOOL="true" + fi pushd $TESTNETDIR/filegen + ./filegen \ -output-directory $CONFIGGENERATOROUTPUTDIR \ -num-of-shards $SHARDCOUNT \ @@ -20,7 +25,8 @@ generateConfig() { -metachain-consensus-group-size $META_CONSENSUS_SIZE \ -stake-type $GENESIS_STAKE_TYPE \ -hysteresis $HYSTERESIS \ - -sovereign=$SOVEREIGN_DEPLOY + -round-duration $ROUND_DURATION \ + -sovereign=$SOVEREIGN_BOOL popd } @@ -146,6 +152,8 @@ updateNodeConfig() { sed -i '/^\[ElasticSearchConnector\]/,/^\[/ s/Enabled *= *false/Enabled = true/' external_observer.toml fi + sed -i '/^\[DbLookupExtensions\]/,/^\[/ s/Enabled *= *false/Enabled = true/' config_observer.toml + cp nodesSetup_edit.json nodesSetup.json rm nodesSetup_edit.json @@ -190,6 +198,23 @@ updateProxyConfig() { popd } +updateSovereignProxyConfig() { + pushd $TESTNETDIR/proxy/config + cp config.toml config_edit.toml + + # Truncate config.toml before the [[Observers]] list + sed -i -n '/\[\[Observers\]\]/q;p' config_edit.toml + + updateTOMLValue config_edit.toml "ServerPort" $PORT_PROXY + generateSovereignProxyObserverList config_edit.toml + + cp config_edit.toml config.toml + rm config_edit.toml + + echo "Updated configuration for the Sovereign Proxy." + popd +} + copyTxGenConfig() { pushd $TESTNETDIR @@ -221,6 +246,13 @@ updateTxGenConfig() { popd } +updateSovereignTxGenConfig() { + updateTxGenConfig + pushd $TESTNETDIR/txgen/config/nodeConfig/config + updateTOMLValue enableEpochs.toml "SCDeployEnableEpoch" 0 + updateTOMLValue enableEpochs.toml "BuiltInFunctionsEnableEpoch" 0 + updateTOMLValue enableEpochs.toml "ESDTEnableEpoch" 0 +} generateProxyObserverList() { OBSERVER_INDEX=0 @@ -252,6 +284,31 @@ generateProxyObserverList() { done } +generateSovereignProxyObserverList() { + OBSERVER_INDEX=0 + OUTPUTFILE=$! + # Start Shard Observers + (( max_shard_id=$SHARDCOUNT - 1 )) + for SHARD in $(seq 0 1 $max_shard_id); do + for _ in $(seq $SHARD_OBSERVERCOUNT); do + (( PORT=$PORT_ORIGIN_OBSERVER_REST+$OBSERVER_INDEX)) + + echo "[[Observers]]" >> config_edit.toml + echo " ShardId = $SHARD" >> config_edit.toml + echo " Address = \"http://127.0.0.1:$PORT\"" >> config_edit.toml + echo ""$'\n' >> config_edit.toml + + # for sovereign shards, shard observers are also able to respond to Metachain related endpoints - useful so we can reuse the Proxy without changes + echo "[[Observers]]" >> config_edit.toml + echo " ShardId = $METASHARD_ID" >> config_edit.toml + echo " Address = \"http://127.0.0.1:$PORT\"" >> config_edit.toml + echo ""$'\n' >> config_edit.toml + + (( OBSERVER_INDEX++ )) + done + done +} + updateTOMLValue() { local filename=$1 local key=$2 diff --git a/scripts/testnet/txgen-basic.sh b/scripts/testnet/txgen-basic.sh index 68a0375e3b8..0c2b84fdbf7 100755 --- a/scripts/testnet/txgen-basic.sh +++ b/scripts/testnet/txgen-basic.sh @@ -8,7 +8,7 @@ if [[ -n $1 ]]; then DESTINATION=$1 fi -NUM_TXS=250 +NUM_TXS=25000 VALUE=1 GAS_PRICE=1000000000 GAS_LIMIT=50000 diff --git a/scripts/testnet/txgen-erc20.sh b/scripts/testnet/txgen-erc20.sh index 8802a56cf33..50114435bee 100755 --- a/scripts/testnet/txgen-erc20.sh +++ b/scripts/testnet/txgen-erc20.sh @@ -8,7 +8,7 @@ if [[ -n $1 ]]; then DESTINATION=$1 fi -NUM_TXS=100 +NUM_TXS=10000 VALUE=1 GAS_PRICE=1000000000 GAS_LIMIT=3000000 diff --git a/scripts/testnet/txgen-esdt.sh b/scripts/testnet/txgen-esdt.sh index e14f33607ec..9cadde64858 100755 --- a/scripts/testnet/txgen-esdt.sh +++ b/scripts/testnet/txgen-esdt.sh @@ -8,7 +8,7 @@ if [[ -n $1 ]]; then DESTINATION=$1 fi -NUM_TXS=50 +NUM_TXS=5000 VALUE=10 GAS_PRICE=1000000000 GAS_LIMIT=100000 diff --git a/scripts/testnet/variables.sh b/scripts/testnet/variables.sh index 033b08de83b..e733f384618 100644 --- a/scripts/testnet/variables.sh +++ b/scripts/testnet/variables.sh @@ -12,12 +12,12 @@ export USE_PROXY=1 # Enable the MultiversX Transaction Generator. Note that this is a private # repository (mx-chain-txgen-go). -export USE_TXGEN=0 +export USE_TXGEN=1 # Enable the Elasticsearch data indexing. Will run a Docker image containing an Elasticsearch cluster, on port 9200. # It will also change the external.toml files for observers, so they can index data into it. # Docker must be managed as a non-root user: https://docs.docker.com/engine/install/linux-postinstall/ -export USE_ELASTICSEARCH=0 +export USE_ELASTICSEARCH=1 # Path where the testnet will be instantiated. This folder is assumed to not # exist, but it doesn't matter if it already does. It will be created if not, @@ -60,14 +60,16 @@ export GENESIS_STAKE_TYPE="direct" #'delegated' or 'direct' as in direct stake #if set to 1, each observer will turn off the antiflooding capability, allowing spam in our network export OBSERVERS_ANTIFLOOD_DISABLE=0 -# If set to true, this will deploy nodes in a sovereign shard. +# If set to 1, this will deploy nodes in a sovereign shard. # All variables from metashard structure(validators, observers, consensus) should be set to zero and SHARDCOUNT to 1 # For now, make sure that you checkout feat/sovereign branch from mx-chain-deploy repo when using these scripts -export SOVEREIGN_DEPLOY=true +export SOVEREIGN_DEPLOY=1 + +export ROUND_DURATION=4000 # Shard structure export SHARDCOUNT=1 -export SHARD_VALIDATORCOUNT=2 +export SHARD_VALIDATORCOUNT=3 export SHARD_OBSERVERCOUNT=1 export SHARD_CONSENSUS_SIZE=2 @@ -154,7 +156,7 @@ export NUMACCOUNTS="250" # Whether txgen should regenerate its accounts when starting, or not. # Recommended value is 1, but 0 is useful to run the txgen a second time, to # continue a testing session on the same accounts. -export TXGEN_REGENERATE_ACCOUNTS=0 +export TXGEN_REGENERATE_ACCOUNTS=1 # COPY_BACK_CONFIGS when set to 1 will copy back the configs and keys to the ./cmd/node/config directory # in order to have a node in the IDE that can run a node in debug mode but in the same network with the rest of the nodes From d51c3d402a0e527a1972afb7a8675d5dd0bbe899 Mon Sep 17 00:00:00 2001 From: axenteoctavian Date: Thu, 11 Jan 2024 12:32:36 +0200 Subject: [PATCH 23/56] fix spaces --- scripts/testnet/include/config.sh | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/scripts/testnet/include/config.sh b/scripts/testnet/include/config.sh index e36ac037afa..b92677919c3 100644 --- a/scripts/testnet/include/config.sh +++ b/scripts/testnet/include/config.sh @@ -12,8 +12,8 @@ generateConfig() { if [ $USE_HARDFORK -eq 1 ]; then SOVEREIGN_BOOL="true" fi - pushd $TESTNETDIR/filegen + pushd $TESTNETDIR/filegen ./filegen \ -output-directory $CONFIGGENERATOROUTPUTDIR \ -num-of-shards $SHARDCOUNT \ From e0a845605abd197cb3321ab6c8899812bcec8ded Mon Sep 17 00:00:00 2001 From: axenteoctavian Date: Thu, 11 Jan 2024 13:11:11 +0200 Subject: [PATCH 24/56] fixes after review --- scripts/testnet/variables.sh | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/scripts/testnet/variables.sh b/scripts/testnet/variables.sh index e733f384618..20ca6f06cd4 100644 --- a/scripts/testnet/variables.sh +++ b/scripts/testnet/variables.sh @@ -12,12 +12,12 @@ export USE_PROXY=1 # Enable the MultiversX Transaction Generator. Note that this is a private # repository (mx-chain-txgen-go). -export USE_TXGEN=1 +export USE_TXGEN=0 # Enable the Elasticsearch data indexing. Will run a Docker image containing an Elasticsearch cluster, on port 9200. # It will also change the external.toml files for observers, so they can index data into it. # Docker must be managed as a non-root user: https://docs.docker.com/engine/install/linux-postinstall/ -export USE_ELASTICSEARCH=1 +export USE_ELASTICSEARCH=0 # Path where the testnet will be instantiated. This folder is assumed to not # exist, but it doesn't matter if it already does. It will be created if not, From 1c69efc76478e848cf91f8dcfc9cd7cfff3c9dec Mon Sep 17 00:00:00 2001 From: axenteoctavian Date: Thu, 11 Jan 2024 13:22:14 +0200 Subject: [PATCH 25/56] rollback values --- scripts/testnet/txgen-basic.sh | 2 +- scripts/testnet/txgen-erc20.sh | 2 +- scripts/testnet/txgen-esdt.sh | 2 +- 3 files changed, 3 insertions(+), 3 deletions(-) diff --git a/scripts/testnet/txgen-basic.sh b/scripts/testnet/txgen-basic.sh index 0c2b84fdbf7..68a0375e3b8 100755 --- a/scripts/testnet/txgen-basic.sh +++ b/scripts/testnet/txgen-basic.sh @@ -8,7 +8,7 @@ if [[ -n $1 ]]; then DESTINATION=$1 fi -NUM_TXS=25000 +NUM_TXS=250 VALUE=1 GAS_PRICE=1000000000 GAS_LIMIT=50000 diff --git a/scripts/testnet/txgen-erc20.sh b/scripts/testnet/txgen-erc20.sh index 50114435bee..8802a56cf33 100755 --- a/scripts/testnet/txgen-erc20.sh +++ b/scripts/testnet/txgen-erc20.sh @@ -8,7 +8,7 @@ if [[ -n $1 ]]; then DESTINATION=$1 fi -NUM_TXS=10000 +NUM_TXS=100 VALUE=1 GAS_PRICE=1000000000 GAS_LIMIT=3000000 diff --git a/scripts/testnet/txgen-esdt.sh b/scripts/testnet/txgen-esdt.sh index 9cadde64858..e14f33607ec 100755 --- a/scripts/testnet/txgen-esdt.sh +++ b/scripts/testnet/txgen-esdt.sh @@ -8,7 +8,7 @@ if [[ -n $1 ]]; then DESTINATION=$1 fi -NUM_TXS=5000 +NUM_TXS=50 VALUE=10 GAS_PRICE=1000000000 GAS_LIMIT=100000 From 66bf411e367f68d4be6737afa978e530f1d8521c Mon Sep 17 00:00:00 2001 From: axenteoctavian Date: Thu, 11 Jan 2024 13:33:58 +0200 Subject: [PATCH 26/56] fix ater review --- scripts/testnet/deploySovereignScreen.sh | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/scripts/testnet/deploySovereignScreen.sh b/scripts/testnet/deploySovereignScreen.sh index a5ea123df4c..5fa7e72820b 100644 --- a/scripts/testnet/deploySovereignScreen.sh +++ b/scripts/testnet/deploySovereignScreen.sh @@ -33,4 +33,4 @@ screen -L -Logfile txgenErc20Log.txt -d -m -S txgenErc20Screen ./sovereign-txgen echo -e "${GREEN}Starting sending the esdt scenario transactions...${NC}" screen -L -Logfile txgenEsdtLog.txt -d -m -S txgenEsdtScreen ./sovereign-txgen-esdt.sh -echo -e "${GREEN}Finished the sovereign chain deployment. Don't forget to stop it with ./stop.sh at the end.${NC}" \ No newline at end of file +echo -e "${GREEN}Finished the sovereign chain deployment. Don't forget to stop it with ./stop.sh at the end.${NC}" From f4718d69a03023c79e2f4e9f63ce6b1f54c5dbe9 Mon Sep 17 00:00:00 2001 From: axenteoctavian Date: Thu, 11 Jan 2024 14:39:43 +0200 Subject: [PATCH 27/56] fixes after review (renaming) --- factory/api/apiResolverFactory.go | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/factory/api/apiResolverFactory.go b/factory/api/apiResolverFactory.go index e42499d5842..318470c0120 100644 --- a/factory/api/apiResolverFactory.go +++ b/factory/api/apiResolverFactory.go @@ -27,7 +27,7 @@ import ( "github.com/multiversx/mx-chain-go/process" "github.com/multiversx/mx-chain-go/process/coordinator" "github.com/multiversx/mx-chain-go/process/economics" - factory2 "github.com/multiversx/mx-chain-go/process/factory" + processFactory "github.com/multiversx/mx-chain-go/process/factory" "github.com/multiversx/mx-chain-go/process/factory/metachain" "github.com/multiversx/mx-chain-go/process/factory/shard" "github.com/multiversx/mx-chain-go/process/smartContract" @@ -501,12 +501,12 @@ func addSystemVMToContainer(args *scQueryElementArgs, vmContainer process.Virtua return err } - vmMeta, err := vmContainerMeta.Get(factory2.SystemVirtualMachine) + vmMeta, err := vmContainerMeta.Get(processFactory.SystemVirtualMachine) if err != nil { return err } - err = vmContainer.Add(factory2.SystemVirtualMachine, vmMeta) + err = vmContainer.Add(processFactory.SystemVirtualMachine, vmMeta) if err != nil { return err } From 7228701c96cbb195e55a1c0f4a34d587492d0963 Mon Sep 17 00:00:00 2001 From: axenteoctavian Date: Thu, 11 Jan 2024 18:05:07 +0200 Subject: [PATCH 28/56] fix test after review --- .../process/sovereignGenesisBlockCreator_test.go | 13 +++++++------ 1 file changed, 7 insertions(+), 6 deletions(-) diff --git a/genesis/process/sovereignGenesisBlockCreator_test.go b/genesis/process/sovereignGenesisBlockCreator_test.go index f9f32f7594f..22bc9aa1ee7 100644 --- a/genesis/process/sovereignGenesisBlockCreator_test.go +++ b/genesis/process/sovereignGenesisBlockCreator_test.go @@ -168,17 +168,19 @@ func TestSovereignGenesisBlockCreator_InitSystemAccountCalled(t *testing.T) { loadAccountWasCalled := false saveAccountWasCalled := false - var systemAccountLoaded []byte accountsAdapter := &state.AccountsStub{ LoadAccountCalled: func(address []byte) (vmcommon.AccountHandler, error) { - loadAccountWasCalled = true - if systemAccountLoaded == nil { // first loaded account saved (from initSystemAccount) - systemAccountLoaded = address + if !loadAccountWasCalled { // first loaded account + loadAccountWasCalled = true + require.Equal(t, core.SystemAccountAddress, address) } return state.NewAccountWrapMock(address), nil }, SaveAccountCalled: func(account vmcommon.AccountHandler) error { - saveAccountWasCalled = true + if !saveAccountWasCalled { // first saved account + saveAccountWasCalled = true + require.Equal(t, core.SystemAccountAddress, account.AddressBytes()) + } return nil }, } @@ -192,5 +194,4 @@ func TestSovereignGenesisBlockCreator_InitSystemAccountCalled(t *testing.T) { require.NotNil(t, sgbc) require.True(t, loadAccountWasCalled) require.True(t, saveAccountWasCalled) - require.Equal(t, systemAccountLoaded, core.SystemAccountAddress) } From dcfdd3b85bdfbd6317160eb4fbcecff6b8385395 Mon Sep 17 00:00:00 2001 From: axenteoctavian Date: Fri, 12 Jan 2024 11:30:52 +0200 Subject: [PATCH 29/56] fixes after review, added staked value factory --- cmd/sovereignnode/sovereignNodeRunner.go | 1 + factory/api/apiResolverFactory.go | 3 +- factory/api/apiResolverFactory_test.go | 10 +++++ factory/errors.go | 3 ++ .../testProcessorNodeWithTestWebServer.go | 2 +- node/nodeRunner.go | 1 + .../delegatedListHandlerFactory_test.go | 30 +++++++------ .../directStakedListHandlerFactory_test.go | 23 ++-------- node/trieIterators/factory/interface.go | 6 +++ .../sovereignDelegatedListHandlerFactory.go | 2 +- ...vereignDelegatedListHandlerFactory_test.go | 17 +------- ...sovereignDirectStakedListHandlerFactory.go | 2 +- ...eignDirectStakedListHandlerFactory_test.go | 17 +------- .../sovereignStakeValuesHandlerFactory.go | 24 +++++++++++ ...sovereignStakeValuesHandlerFactory_test.go | 27 ++++++++++++ .../factory/stakeValuesHandlerFactory.go | 17 +++++++- .../factory/stakeValuesHandlerFactory_test.go | 43 ++++++++----------- 17 files changed, 134 insertions(+), 94 deletions(-) create mode 100644 node/trieIterators/factory/sovereignStakeValuesHandlerFactory.go create mode 100644 node/trieIterators/factory/sovereignStakeValuesHandlerFactory_test.go diff --git a/cmd/sovereignnode/sovereignNodeRunner.go b/cmd/sovereignnode/sovereignNodeRunner.go index efa1c607d71..eeab5c75789 100644 --- a/cmd/sovereignnode/sovereignNodeRunner.go +++ b/cmd/sovereignnode/sovereignNodeRunner.go @@ -694,6 +694,7 @@ func (snr *sovereignNodeRunner) createApiFacade( ChainRunType: common.ChainRunTypeSovereign, DelegatedListFactoryHandler: trieIteratorsFactory.NewSovereignDelegatedListProcessorFactory(), DirectStakedListFactoryHandler: trieIteratorsFactory.NewSovereignDirectStakedListProcessorFactory(), + TotalStakedValueFactoryHandler: trieIteratorsFactory.NewSovereignTotalStakedValueProcessorFactory(), } apiResolver, err := apiComp.CreateApiResolver(apiResolverArgs) diff --git a/factory/api/apiResolverFactory.go b/factory/api/apiResolverFactory.go index 56651fb3b4c..085fca3ca75 100644 --- a/factory/api/apiResolverFactory.go +++ b/factory/api/apiResolverFactory.go @@ -72,6 +72,7 @@ type ApiResolverArgs struct { ChainRunType common.ChainRunType DelegatedListFactoryHandler trieIteratorsFactory.DelegatedListProcessorFactoryHandler DirectStakedListFactoryHandler trieIteratorsFactory.DirectStakedListProcessorFactoryHandler + TotalStakedValueFactoryHandler trieIteratorsFactory.TotalStakedValueProcessorFactoryHandler } type scQueryServiceArgs struct { @@ -207,7 +208,7 @@ func CreateApiResolver(args *ApiResolverArgs) (facade.ApiResolver, error) { PublicKeyConverter: args.CoreComponents.AddressPubKeyConverter(), QueryService: scQueryService, } - totalStakedValueHandler, err := trieIteratorsFactory.CreateTotalStakedValueHandler(argsProcessors) + totalStakedValueHandler, err := args.TotalStakedValueFactoryHandler.CreateTotalStakedValueProcessorHandler(argsProcessors) if err != nil { return nil, err } diff --git a/factory/api/apiResolverFactory_test.go b/factory/api/apiResolverFactory_test.go index 39aa4ba3783..e295b189e35 100644 --- a/factory/api/apiResolverFactory_test.go +++ b/factory/api/apiResolverFactory_test.go @@ -113,6 +113,7 @@ func createMockArgs(t *testing.T) *api.ApiResolverArgs { ChainRunType: common.ChainRunTypeRegular, DelegatedListFactoryHandler: trieIteratorsFactory.NewDelegatedListProcessorFactory(), DirectStakedListFactoryHandler: trieIteratorsFactory.NewDirectStakedListProcessorFactory(), + TotalStakedValueFactoryHandler: trieIteratorsFactory.NewTotalStakedListProcessorFactory(), } } @@ -306,6 +307,15 @@ func TestCreateApiResolver(t *testing.T) { require.Equal(t, factoryErrors.ErrNilDirectStakedListFactory, err) require.True(t, check.IfNil(apiResolver)) }) + t.Run("TotalStakedValueFactoryHandler nil should error", func(t *testing.T) { + t.Parallel() + + args := createMockArgs(t) + args.TotalStakedValueFactoryHandler = nil + apiResolver, err := api.CreateApiResolver(args) + require.Equal(t, factoryErrors.ErrNilTotalStakedValueFactory, err) + require.True(t, check.IfNil(apiResolver)) + }) } func createMockSCQueryElementArgs() api.SCQueryElementArgs { diff --git a/factory/errors.go b/factory/errors.go index dc1e3aa6adb..34de2e2e12a 100644 --- a/factory/errors.go +++ b/factory/errors.go @@ -7,3 +7,6 @@ var ErrNilDelegatedListFactory = errors.New("nil delegated list factory has been // ErrNilDirectStakedListFactory signal that a nil direct staked list handler factory has been provided var ErrNilDirectStakedListFactory = errors.New("nil direct staked list factory has been provided") + +// ErrNilTotalStakedValueFactory signal that a nil total staked value handler factory has been provided +var ErrNilTotalStakedValueFactory = errors.New("nil total staked value handler factory has been provided") diff --git a/integrationTests/testProcessorNodeWithTestWebServer.go b/integrationTests/testProcessorNodeWithTestWebServer.go index 89b5d57d462..9eb4583228a 100644 --- a/integrationTests/testProcessorNodeWithTestWebServer.go +++ b/integrationTests/testProcessorNodeWithTestWebServer.go @@ -209,7 +209,7 @@ func createFacadeComponents(tpn *TestProcessorNode) nodeFacade.ApiResolver { QueryService: tpn.SCQueryService, PublicKeyConverter: TestAddressPubkeyConverter, } - totalStakedValueHandler, err := factory.CreateTotalStakedValueHandler(args) + totalStakedValueHandler, err := factory.NewTotalStakedListProcessorFactory().CreateTotalStakedValueProcessorHandler(args) log.LogIfError(err) directStakedListHandler, err := factory.NewDirectStakedListProcessorFactory().CreateDirectStakedListProcessorHandler(args) diff --git a/node/nodeRunner.go b/node/nodeRunner.go index 4f594f22993..7d1ba7e8a73 100644 --- a/node/nodeRunner.go +++ b/node/nodeRunner.go @@ -723,6 +723,7 @@ func (nr *nodeRunner) createApiFacade( ChainRunType: common.ChainRunTypeRegular, DelegatedListFactoryHandler: trieIteratorsFactory.NewDelegatedListProcessorFactory(), DirectStakedListFactoryHandler: trieIteratorsFactory.NewDirectStakedListProcessorFactory(), + TotalStakedValueFactoryHandler: trieIteratorsFactory.NewTotalStakedListProcessorFactory(), } apiResolver, err := apiComp.CreateApiResolver(apiResolverArgs) diff --git a/node/trieIterators/factory/delegatedListHandlerFactory_test.go b/node/trieIterators/factory/delegatedListHandlerFactory_test.go index 5264b2bbe52..a77f84dce45 100644 --- a/node/trieIterators/factory/delegatedListHandlerFactory_test.go +++ b/node/trieIterators/factory/delegatedListHandlerFactory_test.go @@ -14,6 +14,18 @@ import ( "github.com/stretchr/testify/require" ) +func createMockArgs(shardId uint32) trieIterators.ArgTrieIteratorProcessor { + return trieIterators.ArgTrieIteratorProcessor{ + ShardID: shardId, + Accounts: &trieIterators.AccountsWrapper{ + Mutex: &sync.Mutex{}, + AccountsAdapter: &stateMock.AccountsStub{}, + }, + PublicKeyConverter: &testscommon.PubkeyConverterMock{}, + QueryService: &mock.SCQueryServiceStub{}, + } +} + func TestNewDelegatedListProcessorFactory(t *testing.T) { t.Parallel() @@ -21,30 +33,20 @@ func TestNewDelegatedListProcessorFactory(t *testing.T) { require.False(t, delegatedListHandlerFactory.IsInterfaceNil()) } -func TestDelegatedListProcessorFactory_CreateDelegatedListProcessorHandler_Disabled(t *testing.T) { +func TestDelegatedListProcessorFactory_CreateDelegatedListProcessorHandlerDisabledProcessor(t *testing.T) { t.Parallel() - args := trieIterators.ArgTrieIteratorProcessor{ - ShardID: 0, - } + args := createMockArgs(0) delegatedListHandler, err := trieIteratorsFactory.NewDelegatedListProcessorFactory().CreateDelegatedListProcessorHandler(args) require.Nil(t, err) require.Equal(t, "*disabled.delegatedListProcessor", fmt.Sprintf("%T", delegatedListHandler)) } -func TestDelegatedListProcessorFactory_CreateDelegatedListProcessorHandler_DelegatedListProcessorFactory(t *testing.T) { +func TestDelegatedListProcessorFactory_CreateDelegatedListProcessorHandler(t *testing.T) { t.Parallel() - args := trieIterators.ArgTrieIteratorProcessor{ - ShardID: core.MetachainShardId, - Accounts: &trieIterators.AccountsWrapper{ - Mutex: &sync.Mutex{}, - AccountsAdapter: &stateMock.AccountsStub{}, - }, - PublicKeyConverter: &testscommon.PubkeyConverterMock{}, - QueryService: &mock.SCQueryServiceStub{}, - } + args := createMockArgs(core.MetachainShardId) delegatedListHandler, err := trieIteratorsFactory.NewDelegatedListProcessorFactory().CreateDelegatedListProcessorHandler(args) require.Nil(t, err) diff --git a/node/trieIterators/factory/directStakedListHandlerFactory_test.go b/node/trieIterators/factory/directStakedListHandlerFactory_test.go index 38b660b18f9..64df9c1c994 100644 --- a/node/trieIterators/factory/directStakedListHandlerFactory_test.go +++ b/node/trieIterators/factory/directStakedListHandlerFactory_test.go @@ -2,15 +2,10 @@ package factory_test import ( "fmt" - "sync" "testing" "github.com/multiversx/mx-chain-core-go/core" - "github.com/multiversx/mx-chain-go/node/mock" - "github.com/multiversx/mx-chain-go/node/trieIterators" trieIteratorsFactory "github.com/multiversx/mx-chain-go/node/trieIterators/factory" - "github.com/multiversx/mx-chain-go/testscommon" - stateMock "github.com/multiversx/mx-chain-go/testscommon/state" "github.com/stretchr/testify/require" ) @@ -21,30 +16,20 @@ func TestNewDirectStakedListProcessorFactory(t *testing.T) { require.False(t, directStakedListHandlerFactory.IsInterfaceNil()) } -func TestDirectStakedListProcessorFactory_CreateDirectStakedListProcessor_Disabled(t *testing.T) { +func TestDirectStakedListProcessorFactory_CreateDirectStakedListProcessorHandlerDisabledProcessor(t *testing.T) { t.Parallel() - args := trieIterators.ArgTrieIteratorProcessor{ - ShardID: 0, - } + args := createMockArgs(0) directStakedListHandler, err := trieIteratorsFactory.NewDirectStakedListProcessorFactory().CreateDirectStakedListProcessorHandler(args) require.Nil(t, err) require.Equal(t, "*disabled.directStakedListProcessor", fmt.Sprintf("%T", directStakedListHandler)) } -func TestDirectStakedListProcessorFactory_CreateDirectStakedListProcessor_DirectStakedListProcessorFactory(t *testing.T) { +func TestDirectStakedListProcessorFactory_CreateDirectStakedListProcessorHandler(t *testing.T) { t.Parallel() - args := trieIterators.ArgTrieIteratorProcessor{ - ShardID: core.MetachainShardId, - Accounts: &trieIterators.AccountsWrapper{ - Mutex: &sync.Mutex{}, - AccountsAdapter: &stateMock.AccountsStub{}, - }, - PublicKeyConverter: &testscommon.PubkeyConverterMock{}, - QueryService: &mock.SCQueryServiceStub{}, - } + args := createMockArgs(core.MetachainShardId) directStakedListHandler, err := trieIteratorsFactory.NewDirectStakedListProcessorFactory().CreateDirectStakedListProcessorHandler(args) require.Nil(t, err) diff --git a/node/trieIterators/factory/interface.go b/node/trieIterators/factory/interface.go index 0488f64289b..22dff265f14 100644 --- a/node/trieIterators/factory/interface.go +++ b/node/trieIterators/factory/interface.go @@ -16,3 +16,9 @@ type DirectStakedListProcessorFactoryHandler interface { CreateDirectStakedListProcessorHandler(args trieIterators.ArgTrieIteratorProcessor) (external.DirectStakedListHandler, error) IsInterfaceNil() bool } + +// TotalStakedValueProcessorFactoryHandler can create direct staked list processor handler +type TotalStakedValueProcessorFactoryHandler interface { + CreateTotalStakedValueProcessorHandler(args trieIterators.ArgTrieIteratorProcessor) (external.TotalStakedValueHandler, error) + IsInterfaceNil() bool +} diff --git a/node/trieIterators/factory/sovereignDelegatedListHandlerFactory.go b/node/trieIterators/factory/sovereignDelegatedListHandlerFactory.go index 5332c323101..8db12a8d549 100644 --- a/node/trieIterators/factory/sovereignDelegatedListHandlerFactory.go +++ b/node/trieIterators/factory/sovereignDelegatedListHandlerFactory.go @@ -13,7 +13,7 @@ func NewSovereignDelegatedListProcessorFactory() *sovereignDelegatedListProcesso return &sovereignDelegatedListProcessorFactory{} } -// CreateDelegatedListProcessorHandler creates a new instance of DirectStakedListHandler +// CreateDelegatedListProcessorHandler creates a new instance of delegated list processor for sovereign chains func (sd *sovereignDelegatedListProcessorFactory) CreateDelegatedListProcessorHandler(args trieIterators.ArgTrieIteratorProcessor) (external.DelegatedListHandler, error) { return trieIterators.NewDelegatedListProcessor(args) } diff --git a/node/trieIterators/factory/sovereignDelegatedListHandlerFactory_test.go b/node/trieIterators/factory/sovereignDelegatedListHandlerFactory_test.go index fdcff6c7866..d03746e73f1 100644 --- a/node/trieIterators/factory/sovereignDelegatedListHandlerFactory_test.go +++ b/node/trieIterators/factory/sovereignDelegatedListHandlerFactory_test.go @@ -2,15 +2,10 @@ package factory_test import ( "fmt" - "sync" "testing" "github.com/multiversx/mx-chain-core-go/core" - "github.com/multiversx/mx-chain-go/node/mock" - "github.com/multiversx/mx-chain-go/node/trieIterators" trieIteratorsFactory "github.com/multiversx/mx-chain-go/node/trieIterators/factory" - "github.com/multiversx/mx-chain-go/testscommon" - stateMock "github.com/multiversx/mx-chain-go/testscommon/state" "github.com/stretchr/testify/require" ) @@ -21,18 +16,10 @@ func TestNewSovereignDelegatedListProcessorFactory(t *testing.T) { require.False(t, sovereignDelegatedListHandlerFactory.IsInterfaceNil()) } -func TestSovereignDelegatedListProcessorFactory_CreateDelegatedListProcessorHandler_DelegatedListProcessorFactory(t *testing.T) { +func TestSovereignDelegatedListProcessorFactory_CreateDelegatedListProcessorHandler(t *testing.T) { t.Parallel() - args := trieIterators.ArgTrieIteratorProcessor{ - ShardID: core.MetachainShardId, - Accounts: &trieIterators.AccountsWrapper{ - Mutex: &sync.Mutex{}, - AccountsAdapter: &stateMock.AccountsStub{}, - }, - PublicKeyConverter: &testscommon.PubkeyConverterMock{}, - QueryService: &mock.SCQueryServiceStub{}, - } + args := createMockArgs(core.SovereignChainShardId) sovereignDelegatedListHandler, err := trieIteratorsFactory.NewSovereignDelegatedListProcessorFactory().CreateDelegatedListProcessorHandler(args) require.Nil(t, err) diff --git a/node/trieIterators/factory/sovereignDirectStakedListHandlerFactory.go b/node/trieIterators/factory/sovereignDirectStakedListHandlerFactory.go index 72c611d526d..05723ef2e49 100644 --- a/node/trieIterators/factory/sovereignDirectStakedListHandlerFactory.go +++ b/node/trieIterators/factory/sovereignDirectStakedListHandlerFactory.go @@ -13,7 +13,7 @@ func NewSovereignDirectStakedListProcessorFactory() *sovereignDirectStakedListHa return &sovereignDirectStakedListHandlerFactory{} } -// CreateDirectStakedListProcessorHandler creates a new instance of DirectStakedListHandler +// CreateDirectStakedListProcessorHandler creates a new instance of direct staked list processor for sovereign chains func (ds *sovereignDirectStakedListHandlerFactory) CreateDirectStakedListProcessorHandler(args trieIterators.ArgTrieIteratorProcessor) (external.DirectStakedListHandler, error) { return trieIterators.NewDirectStakedListProcessor(args) } diff --git a/node/trieIterators/factory/sovereignDirectStakedListHandlerFactory_test.go b/node/trieIterators/factory/sovereignDirectStakedListHandlerFactory_test.go index de4cc13a9d7..d453acf7c00 100644 --- a/node/trieIterators/factory/sovereignDirectStakedListHandlerFactory_test.go +++ b/node/trieIterators/factory/sovereignDirectStakedListHandlerFactory_test.go @@ -2,15 +2,10 @@ package factory_test import ( "fmt" - "github.com/multiversx/mx-chain-go/node/trieIterators" - "sync" "testing" "github.com/multiversx/mx-chain-core-go/core" - "github.com/multiversx/mx-chain-go/node/mock" trieIteratorsFactory "github.com/multiversx/mx-chain-go/node/trieIterators/factory" - "github.com/multiversx/mx-chain-go/testscommon" - stateMock "github.com/multiversx/mx-chain-go/testscommon/state" "github.com/stretchr/testify/require" ) @@ -21,18 +16,10 @@ func TestNewSovereignDirectStakedListProcessorFactory(t *testing.T) { require.False(t, directStakedListHandlerFactory.IsInterfaceNil()) } -func TestSovereignDirectStakedListHandlerFactory_CreateDirectStakedListProcessorHandler_DirectStakedListHandlerFactory(t *testing.T) { +func TestSovereignDirectStakedListHandlerFactory_CreateDirectStakedListProcessorHandler(t *testing.T) { t.Parallel() - args := trieIterators.ArgTrieIteratorProcessor{ - ShardID: core.MetachainShardId, - Accounts: &trieIterators.AccountsWrapper{ - Mutex: &sync.Mutex{}, - AccountsAdapter: &stateMock.AccountsStub{}, - }, - PublicKeyConverter: &testscommon.PubkeyConverterMock{}, - QueryService: &mock.SCQueryServiceStub{}, - } + args := createMockArgs(core.SovereignChainShardId) sovereignDirectStakedListHandler, err := trieIteratorsFactory.NewSovereignDirectStakedListProcessorFactory().CreateDirectStakedListProcessorHandler(args) require.Nil(t, err) diff --git a/node/trieIterators/factory/sovereignStakeValuesHandlerFactory.go b/node/trieIterators/factory/sovereignStakeValuesHandlerFactory.go new file mode 100644 index 00000000000..ed388819694 --- /dev/null +++ b/node/trieIterators/factory/sovereignStakeValuesHandlerFactory.go @@ -0,0 +1,24 @@ +package factory + +import ( + "github.com/multiversx/mx-chain-go/node/external" + "github.com/multiversx/mx-chain-go/node/trieIterators" +) + +type sovereignTotalStakedValueProcessorFactory struct { +} + +// NewSovereignTotalStakedValueProcessorFactory create a new sovereign total staked value handler +func NewSovereignTotalStakedValueProcessorFactory() *sovereignTotalStakedValueProcessorFactory { + return &sovereignTotalStakedValueProcessorFactory{} +} + +// CreateTotalStakedValueProcessorHandler will create a new instance of total staked value processor for sovereign chain +func (d *sovereignTotalStakedValueProcessorFactory) CreateTotalStakedValueProcessorHandler(args trieIterators.ArgTrieIteratorProcessor) (external.TotalStakedValueHandler, error) { + return trieIterators.NewTotalStakedValueProcessor(args) +} + +// IsInterfaceNil checks if the underlying pointer is nil +func (d *sovereignTotalStakedValueProcessorFactory) IsInterfaceNil() bool { + return d == nil +} diff --git a/node/trieIterators/factory/sovereignStakeValuesHandlerFactory_test.go b/node/trieIterators/factory/sovereignStakeValuesHandlerFactory_test.go new file mode 100644 index 00000000000..6214585b9c9 --- /dev/null +++ b/node/trieIterators/factory/sovereignStakeValuesHandlerFactory_test.go @@ -0,0 +1,27 @@ +package factory_test + +import ( + "fmt" + "testing" + + "github.com/multiversx/mx-chain-core-go/core" + trieIteratorsFactory "github.com/multiversx/mx-chain-go/node/trieIterators/factory" + "github.com/stretchr/testify/require" +) + +func TestNewSovereignTotalStakedValueProcessorFactory(t *testing.T) { + t.Parallel() + + sovereignDelegatedListHandlerFactory := trieIteratorsFactory.NewSovereignDelegatedListProcessorFactory() + require.False(t, sovereignDelegatedListHandlerFactory.IsInterfaceNil()) +} + +func TestSovereignTotalStakedValueProcessorFactory_CreateSovereignTotalStakedValueProcessorHandler(t *testing.T) { + t.Parallel() + + args := createMockArgs(core.SovereignChainShardId) + + sovereignDelegatedListHandler, err := trieIteratorsFactory.NewSovereignTotalStakedValueProcessorFactory().CreateTotalStakedValueProcessorHandler(args) + require.Nil(t, err) + require.Equal(t, "*trieIterators.stakedValuesProcessor", fmt.Sprintf("%T", sovereignDelegatedListHandler)) +} diff --git a/node/trieIterators/factory/stakeValuesHandlerFactory.go b/node/trieIterators/factory/stakeValuesHandlerFactory.go index 8d26b5aa251..c7e3ff1437c 100644 --- a/node/trieIterators/factory/stakeValuesHandlerFactory.go +++ b/node/trieIterators/factory/stakeValuesHandlerFactory.go @@ -7,11 +7,24 @@ import ( "github.com/multiversx/mx-chain-go/node/trieIterators/disabled" ) -// CreateTotalStakedValueHandler will create a new instance of TotalStakedValueHandler -func CreateTotalStakedValueHandler(args trieIterators.ArgTrieIteratorProcessor) (external.TotalStakedValueHandler, error) { +type totalStakedValueProcessorFactory struct { +} + +// NewTotalStakedListProcessorFactory create a new total staked value handler +func NewTotalStakedListProcessorFactory() *totalStakedValueProcessorFactory { + return &totalStakedValueProcessorFactory{} +} + +// CreateTotalStakedValueProcessorHandler will create a new instance of total staked value processor for regular/normal chain +func (d *totalStakedValueProcessorFactory) CreateTotalStakedValueProcessorHandler(args trieIterators.ArgTrieIteratorProcessor) (external.TotalStakedValueHandler, error) { if args.ShardID != core.MetachainShardId { return disabled.NewDisabledStakeValuesProcessor(), nil } return trieIterators.NewTotalStakedValueProcessor(args) } + +// IsInterfaceNil checks if the underlying pointer is nil +func (d *totalStakedValueProcessorFactory) IsInterfaceNil() bool { + return d == nil +} diff --git a/node/trieIterators/factory/stakeValuesHandlerFactory_test.go b/node/trieIterators/factory/stakeValuesHandlerFactory_test.go index 4dbb74d1d0c..88d75d27aec 100644 --- a/node/trieIterators/factory/stakeValuesHandlerFactory_test.go +++ b/node/trieIterators/factory/stakeValuesHandlerFactory_test.go @@ -1,45 +1,38 @@ -package factory +package factory_test import ( "fmt" - "sync" + trieIteratorsFactory "github.com/multiversx/mx-chain-go/node/trieIterators/factory" "testing" "github.com/multiversx/mx-chain-core-go/core" - "github.com/multiversx/mx-chain-go/node/mock" - "github.com/multiversx/mx-chain-go/node/trieIterators" - "github.com/multiversx/mx-chain-go/testscommon" - stateMock "github.com/multiversx/mx-chain-go/testscommon/state" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" ) -func TestCreateTotalStakedValueHandler_Disabled(t *testing.T) { +func TestNewTotalStakedValueProcessorFactory(t *testing.T) { t.Parallel() - args := trieIterators.ArgTrieIteratorProcessor{ - ShardID: 0, - } + totalStakedValueHandlerFactory := trieIteratorsFactory.NewTotalStakedListProcessorFactory() + require.False(t, totalStakedValueHandlerFactory.IsInterfaceNil()) +} + +func TestTotalStakedValueProcessorFactory_CreateTotalStakedValueProcessorHandlerDisabledProcessor(t *testing.T) { + t.Parallel() - totalStakedValueHandler, err := CreateTotalStakedValueHandler(args) + args := createMockArgs(0) + + totalStakedValueHandlerFactory, err := trieIteratorsFactory.NewTotalStakedListProcessorFactory().CreateTotalStakedValueProcessorHandler(args) require.Nil(t, err) - assert.Equal(t, "*disabled.stakeValuesProcessor", fmt.Sprintf("%T", totalStakedValueHandler)) + assert.Equal(t, "*disabled.stakeValuesProcessor", fmt.Sprintf("%T", totalStakedValueHandlerFactory)) } -func TestCreateTotalStakedValueHandler_TotalStakedValueProcessor(t *testing.T) { +func TestTotalStakedValueProcessorFactory_CreateTotalStakedValueProcessorHandler(t *testing.T) { t.Parallel() - args := trieIterators.ArgTrieIteratorProcessor{ - ShardID: core.MetachainShardId, - Accounts: &trieIterators.AccountsWrapper{ - Mutex: &sync.Mutex{}, - AccountsAdapter: &stateMock.AccountsStub{}, - }, - PublicKeyConverter: &testscommon.PubkeyConverterMock{}, - QueryService: &mock.SCQueryServiceStub{}, - } - - totalStakedValueHandler, err := CreateTotalStakedValueHandler(args) + args := createMockArgs(core.MetachainShardId) + + totalStakedValueHandlerFactory, err := trieIteratorsFactory.NewTotalStakedListProcessorFactory().CreateTotalStakedValueProcessorHandler(args) require.Nil(t, err) - assert.Equal(t, "*trieIterators.stakedValuesProcessor", fmt.Sprintf("%T", totalStakedValueHandler)) + assert.Equal(t, "*trieIterators.stakedValuesProcessor", fmt.Sprintf("%T", totalStakedValueHandlerFactory)) } From 5bfa1b446a1d14433d72152eb2f6f8c2fbfa4613 Mon Sep 17 00:00:00 2001 From: axenteoctavian Date: Fri, 12 Jan 2024 11:38:04 +0200 Subject: [PATCH 30/56] fixes after review --- .../process/sovereignGenesisBlockCreator.go | 12 +++--- .../sovereignGenesisBlockCreator_test.go | 37 ++++++------------- 2 files changed, 18 insertions(+), 31 deletions(-) diff --git a/genesis/process/sovereignGenesisBlockCreator.go b/genesis/process/sovereignGenesisBlockCreator.go index b66cda053cd..ab2fe678e00 100644 --- a/genesis/process/sovereignGenesisBlockCreator.go +++ b/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 } @@ -52,11 +57,6 @@ func (gbc *sovereignGenesisBlockCreator) CreateGenesisBlocks() (map[uint32]data. return nil, err } - err = gbc.initSystemAccount() - if err != nil { - return nil, err - } - return gbc.createSovereignHeaders(argsCreateBlock) } diff --git a/genesis/process/sovereignGenesisBlockCreator_test.go b/genesis/process/sovereignGenesisBlockCreator_test.go index 22bc9aa1ee7..345ac9bc369 100644 --- a/genesis/process/sovereignGenesisBlockCreator_test.go +++ b/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" @@ -166,32 +167,18 @@ func TestSovereignGenesisBlockCreator_InitSystemAccountCalled(t *testing.T) { arg.ShardCoordinator = sharding.NewSovereignShardCoordinator(core.SovereignChainShardId) arg.DNSV2Addresses = []string{"00000000000000000500761b8c4a25d3979359223208b412285f635e71300102"} - loadAccountWasCalled := false - saveAccountWasCalled := false - accountsAdapter := &state.AccountsStub{ - LoadAccountCalled: func(address []byte) (vmcommon.AccountHandler, error) { - if !loadAccountWasCalled { // first loaded account - loadAccountWasCalled = true - require.Equal(t, core.SystemAccountAddress, address) - } - return state.NewAccountWrapMock(address), nil - }, - SaveAccountCalled: func(account vmcommon.AccountHandler) error { - if !saveAccountWasCalled { // first saved account - saveAccountWasCalled = true - require.Equal(t, core.SystemAccountAddress, account.AddressBytes()) - } - return nil - }, - } - arg.Accounts = accountsAdapter - gbc, _ := NewGenesisBlockCreator(arg) sgbc, _ := NewSovereignGenesisBlockCreator(gbc) - _, err := sgbc.CreateGenesisBlocks() - require.NotNil(t, err) - require.NotNil(t, sgbc) - require.True(t, loadAccountWasCalled) - require.True(t, saveAccountWasCalled) + + 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) } From f58528796fd05b615e724179f6ca3fab20494499 Mon Sep 17 00:00:00 2001 From: axenteoctavian Date: Fri, 12 Jan 2024 12:13:31 +0200 Subject: [PATCH 31/56] test fix --- factory/api/apiResolverFactory.go | 3 +++ 1 file changed, 3 insertions(+) diff --git a/factory/api/apiResolverFactory.go b/factory/api/apiResolverFactory.go index 085fca3ca75..c7909748ab6 100644 --- a/factory/api/apiResolverFactory.go +++ b/factory/api/apiResolverFactory.go @@ -125,6 +125,9 @@ func CreateApiResolver(args *ApiResolverArgs) (facade.ApiResolver, error) { if check.IfNilReflect(args.DirectStakedListFactoryHandler) { return nil, factory.ErrNilDirectStakedListFactory } + if check.IfNilReflect(args.TotalStakedValueFactoryHandler) { + return nil, factory.ErrNilTotalStakedValueFactory + } argsSCQuery := &scQueryServiceArgs{ generalConfig: args.Configs.GeneralConfig, From bd5e8fffd00340e5f565063472ba402c678e4df8 Mon Sep 17 00:00:00 2001 From: axenteoctavian Date: Fri, 12 Jan 2024 15:33:24 +0200 Subject: [PATCH 32/56] import fix after review --- node/interface.go | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/node/interface.go b/node/interface.go index 75c18d5a4eb..c08b1ded9d5 100644 --- a/node/interface.go +++ b/node/interface.go @@ -1,13 +1,13 @@ package node import ( - "github.com/multiversx/mx-chain-go/debug" - "github.com/multiversx/mx-chain-go/facade" - mainFactory "github.com/multiversx/mx-chain-go/factory" "io" "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" From 9025d3bfdd364cea4e47a6c5a59884436146447a Mon Sep 17 00:00:00 2001 From: axenteoctavian Date: Fri, 12 Jan 2024 16:38:20 +0200 Subject: [PATCH 33/56] fixes after review --- factory/api/apiResolverFactory.go | 97 ++++++++-------- factory/api/apiResolverFactory_test.go | 151 ++++++++++--------------- factory/api/export_test.go | 4 +- 3 files changed, 112 insertions(+), 140 deletions(-) diff --git a/factory/api/apiResolverFactory.go b/factory/api/apiResolverFactory.go index 318470c0120..8fc260dcedb 100644 --- a/factory/api/apiResolverFactory.go +++ b/factory/api/apiResolverFactory.go @@ -352,23 +352,23 @@ func createScQueryElement( return nil, err } - return smartContract.NewSCQueryService(argsNewSCQueryService) + return smartContract.NewSCQueryService(*argsNewSCQueryService) } -func createArgsSCQueryService(args *scQueryElementArgs) (smartContract.ArgsNewSCQueryService, error) { +func createArgsSCQueryService(args *scQueryElementArgs) (*smartContract.ArgsNewSCQueryService, error) { var err error pkConverter := args.coreComponents.AddressPubKeyConverter() automaticCrawlerAddressesStrings := args.generalConfig.BuiltInFunctions.AutomaticCrawlerAddresses convertedAddresses, errDecode := factory.DecodeAddresses(pkConverter, automaticCrawlerAddressesStrings) if errDecode != nil { - return smartContract.ArgsNewSCQueryService{}, errDecode + return nil, errDecode } dnsV2AddressesStrings := args.generalConfig.BuiltInFunctions.DNSV2Addresses convertedDNSV2Addresses, errDecode := factory.DecodeAddresses(pkConverter, dnsV2AddressesStrings) if errDecode != nil { - return smartContract.ArgsNewSCQueryService{}, errDecode + return nil, errDecode } builtInFuncFactory, err := createBuiltinFuncs( @@ -384,13 +384,13 @@ func createArgsSCQueryService(args *scQueryElementArgs) (smartContract.ArgsNewSC convertedDNSV2Addresses, ) if err != nil { - return smartContract.ArgsNewSCQueryService{}, err + return nil, err } cacherCfg := storageFactory.GetCacherFromConfig(args.generalConfig.SmartContractDataPool) smartContractsCache, err := storageunit.NewCache(cacherCfg) if err != nil { - return smartContract.ArgsNewSCQueryService{}, err + return nil, err } scStorage := args.generalConfig.SmartContractsStorageForSCQuery @@ -416,57 +416,68 @@ func createArgsSCQueryService(args *scQueryElementArgs) (smartContract.ArgsNewSC MissingTrieNodesNotifier: syncer.NewMissingTrieNodesNotifier(), } - apiBlockchain, err := blockchain.NewMetaChain(disabled.NewAppStatusHandler()) - if err != nil { - return smartContract.ArgsNewSCQueryService{}, err - } - argsHook.BlockChain = apiBlockchain - + var apiBlockchain data.ChainHandler var accAdapter state.AccountsAdapterAPI var vmFactory process.VirtualMachinesContainerFactory maxGasForVmQueries := args.generalConfig.VirtualMachine.GasConfig.ShardMaxGasPerVmQuery if args.processComponents.ShardCoordinator().SelfId() == core.MetachainShardId { maxGasForVmQueries = args.generalConfig.VirtualMachine.GasConfig.MetaMaxGasPerVmQuery + apiBlockchain, err = blockchain.NewMetaChain(disabled.NewAppStatusHandler()) + if err != nil { + return nil, err + } + argsHook.BlockChain = apiBlockchain + accAdapter, err = createNewAccountsAdapterApi(args, apiBlockchain) if err != nil { - return smartContract.ArgsNewSCQueryService{}, err + return nil, err } argsHook.Accounts = accAdapter vmFactory, err = createMetaVmContainerFactory(args, argsHook) } else { - accAdapter, vmFactory, err = createShardVmContainerFactory(args, argsHook) + apiBlockchain, err = blockchain.NewBlockChain(disabled.NewAppStatusHandler()) + if err != nil { + return nil, err + } + argsHook.BlockChain = apiBlockchain + + accAdapter, err = createNewAccountsAdapterApi(args, apiBlockchain) + if err != nil { + return nil, err + } argsHook.Accounts = accAdapter + + vmFactory, err = createShardVmContainerFactory(args, argsHook) } + if err != nil { - return smartContract.ArgsNewSCQueryService{}, err + return nil, err } log.Debug("maximum gas per VM Query", "value", maxGasForVmQueries) vmContainer, err := vmFactory.Create() if err != nil { - return smartContract.ArgsNewSCQueryService{}, err + return nil, err } - if args.chainRunType == common.ChainRunTypeSovereign { - err = addSystemVMToContainer(args, vmContainer, argsHook) - if err != nil { - return smartContract.ArgsNewSCQueryService{}, err - } + err = addSystemVMToContainerIfNeeded(args, vmContainer, argsHook) + if err != nil { + return nil, err } err = vmFactory.BlockChainHookImpl().SetVMContainer(vmContainer) if err != nil { - return smartContract.ArgsNewSCQueryService{}, err + return nil, err } err = builtInFuncFactory.SetPayableHandler(vmFactory.BlockChainHookImpl()) if err != nil { - return smartContract.ArgsNewSCQueryService{}, err + return nil, err } - return smartContract.ArgsNewSCQueryService{ + return &smartContract.ArgsNewSCQueryService{ VmContainer: vmContainer, EconomicsFee: args.coreComponents.EconomicsData(), BlockChainHook: vmFactory.BlockChainHookImpl(), @@ -485,10 +496,20 @@ func createArgsSCQueryService(args *scQueryElementArgs) (smartContract.ArgsNewSC }, nil } -func addSystemVMToContainer(args *scQueryElementArgs, vmContainer process.VirtualMachinesContainer, argsHook hooks.ArgBlockChainHook) error { +func addSystemVMToContainerIfNeeded(args *scQueryElementArgs, vmContainer process.VirtualMachinesContainer, argsHook hooks.ArgBlockChainHook) error { + if args.chainRunType != common.ChainRunTypeSovereign { + return nil + } + metaStorage := args.generalConfig.SmartContractsStorage metaStorage.DB.FilePath = metaStorage.DB.FilePath + "_meta" + apiBlockchain, err := blockchain.NewMetaChain(disabled.NewAppStatusHandler()) + if err != nil { + return err + } + argsHook.BlockChain = apiBlockchain + vmFactoryMeta, err := createMetaVmContainerFactory( args, argsHook, ) @@ -537,30 +558,19 @@ func createMetaVmContainerFactory(args *scQueryElementArgs, argsHook hooks.ArgBl EnableEpochsHandler: args.coreComponents.EnableEpochsHandler(), } - vmFactory, err := metachain.NewVMContainerFactory(argsNewVmFactory) - if err != nil { - return nil, err - } - - return vmFactory, nil + return metachain.NewVMContainerFactory(argsNewVmFactory) } -func createShardVmContainerFactory(args *scQueryElementArgs, argsHook hooks.ArgBlockChainHook) (state.AccountsAdapterAPI, process.VirtualMachinesContainerFactory, error) { - accountsAdapterApi, err := createNewAccountsAdapterApi(args, argsHook.BlockChain) - if err != nil { - return nil, nil, err - } - argsHook.Accounts = accountsAdapterApi - +func createShardVmContainerFactory(args *scQueryElementArgs, argsHook hooks.ArgBlockChainHook) (process.VirtualMachinesContainerFactory, error) { queryVirtualMachineConfig := args.generalConfig.VirtualMachine.Querying.VirtualMachineConfig esdtTransferParser, errParser := parsers.NewESDTTransferParser(args.coreComponents.InternalMarshalizer()) if errParser != nil { - return nil, nil, errParser + return nil, errParser } blockChainHookImpl, errBlockChainHook := hooks.NewBlockChainHookImpl(argsHook) if errBlockChainHook != nil { - return nil, nil, errBlockChainHook + return nil, errBlockChainHook } argsNewVMFactory := shard.ArgVMContainerFactory{ @@ -580,12 +590,7 @@ func createShardVmContainerFactory(args *scQueryElementArgs, argsHook hooks.ArgB log.Debug("apiResolver: enable epoch for ahead of time gas usage", "epoch", args.epochConfig.EnableEpochs.AheadOfTimeGasUsageEnableEpoch) log.Debug("apiResolver: enable epoch for repair callback", "epoch", args.epochConfig.EnableEpochs.RepairCallbackEnableEpoch) - vmFactory, err := shard.NewVMContainerFactory(argsNewVMFactory) - if err != nil { - return nil, nil, err - } - - return accountsAdapterApi, vmFactory, nil + return shard.NewVMContainerFactory(argsNewVMFactory) } func createNewAccountsAdapterApi(args *scQueryElementArgs, chainHandler data.ChainHandler) (state.AccountsAdapterAPI, error) { diff --git a/factory/api/apiResolverFactory_test.go b/factory/api/apiResolverFactory_test.go index f29674a06f7..25b29965ecf 100644 --- a/factory/api/apiResolverFactory_test.go +++ b/factory/api/apiResolverFactory_test.go @@ -364,8 +364,51 @@ func createMockSCQueryElementArgs() api.SCQueryElementArgs { return gasSchedule }, }, - MessageSigVerifier: &testscommon.MessageSignVerifierMock{}, - SystemSCConfig: &config.SystemSmartContractsConfig{}, + MessageSigVerifier: &testscommon.MessageSignVerifierMock{}, + SystemSCConfig: &config.SystemSmartContractsConfig{ + ESDTSystemSCConfig: config.ESDTSystemSCConfig{ + BaseIssuingCost: "1000", + OwnerAddress: "erd1fpkcgel4gcmh8zqqdt043yfcn5tyx8373kg6q2qmkxzu4dqamc0swts65c", + }, + GovernanceSystemSCConfig: config.GovernanceSystemSCConfig{ + V1: config.GovernanceSystemSCConfigV1{ + ProposalCost: "500", + NumNodes: 100, + MinQuorum: 50, + MinPassThreshold: 50, + MinVetoThreshold: 50, + }, + Active: config.GovernanceSystemSCConfigActive{ + ProposalCost: "500", + MinQuorum: 0.5, + MinPassThreshold: 0.5, + MinVetoThreshold: 0.5, + }, + OwnerAddress: "erd1vxy22x0fj4zv6hktmydg8vpfh6euv02cz4yg0aaws6rrad5a5awqgqky80", + }, + StakingSystemSCConfig: config.StakingSystemSCConfig{ + GenesisNodePrice: "2500000000000000000000", + MinStakeValue: "1", + UnJailValue: "1", + MinStepValue: "1", + UnBondPeriod: 0, + NumRoundsWithoutBleed: 0, + MaximumPercentageToBleed: 0, + BleedPercentagePerRound: 0, + MaxNumberOfNodesForStake: 10, + ActivateBLSPubKeyMessageVerification: false, + MinUnstakeTokensValue: "1", + }, + DelegationManagerSystemSCConfig: config.DelegationManagerSystemSCConfig{ + MinCreationDeposit: "100", + MinStakeAmount: "100", + ConfigChangeAddress: "erd1vxy22x0fj4zv6hktmydg8vpfh6euv02cz4yg0aaws6rrad5a5awqgqky80", + }, + DelegationSystemSCConfig: config.DelegationSystemSCConfig{ + MinServiceFee: 0, + MaxServiceFee: 100, + }, + }, Bootstrapper: testsMocks.NewTestBootstrapperMock(), AllowVMQueriesChan: make(chan struct{}, 1), WorkingDir: "", @@ -458,53 +501,10 @@ func TestCreateApiResolver_createScQueryElement(t *testing.T) { func TestCreateApiResolver_createArgsSCQueryService(t *testing.T) { t.Parallel() - t.Run("sovereign should add systemVM", func(t *testing.T) { + t.Run("sovereign chain should add systemVM", func(t *testing.T) { t.Parallel() + args := createMockSCQueryElementArgs() - args.SystemSCConfig = &config.SystemSmartContractsConfig{ - ESDTSystemSCConfig: config.ESDTSystemSCConfig{ - BaseIssuingCost: "1000", - OwnerAddress: "erd1fpkcgel4gcmh8zqqdt043yfcn5tyx8373kg6q2qmkxzu4dqamc0swts65c", - }, - GovernanceSystemSCConfig: config.GovernanceSystemSCConfig{ - V1: config.GovernanceSystemSCConfigV1{ - ProposalCost: "500", - NumNodes: 100, - MinQuorum: 50, - MinPassThreshold: 50, - MinVetoThreshold: 50, - }, - Active: config.GovernanceSystemSCConfigActive{ - ProposalCost: "500", - MinQuorum: 0.5, - MinPassThreshold: 0.5, - MinVetoThreshold: 0.5, - }, - OwnerAddress: "erd1vxy22x0fj4zv6hktmydg8vpfh6euv02cz4yg0aaws6rrad5a5awqgqky80", - }, - StakingSystemSCConfig: config.StakingSystemSCConfig{ - GenesisNodePrice: "2500000000000000000000", - MinStakeValue: "1", - UnJailValue: "1", - MinStepValue: "1", - UnBondPeriod: 0, - NumRoundsWithoutBleed: 0, - MaximumPercentageToBleed: 0, - BleedPercentagePerRound: 0, - MaxNumberOfNodesForStake: 10, - ActivateBLSPubKeyMessageVerification: false, - MinUnstakeTokensValue: "1", - }, - DelegationManagerSystemSCConfig: config.DelegationManagerSystemSCConfig{ - MinCreationDeposit: "100", - MinStakeAmount: "100", - ConfigChangeAddress: "erd1vxy22x0fj4zv6hktmydg8vpfh6euv02cz4yg0aaws6rrad5a5awqgqky80", - }, - DelegationSystemSCConfig: config.DelegationSystemSCConfig{ - MinServiceFee: 0, - MaxServiceFee: 100, - }, - } args.ChainRunType = common.ChainRunTypeSovereign argsScQueryService, err := api.CreateArgsSCQueryService(args) @@ -517,54 +517,16 @@ func TestCreateApiResolver_createArgsSCQueryService(t *testing.T) { require.Nil(t, err) require.NotNil(t, svm) require.Equal(t, "*process.systemVM", fmt.Sprintf("%T", svm)) + + wasmvm, err := argsScQueryService.VmContainer.Get(vmFactory.WasmVirtualMachine) + require.Nil(t, err) + require.NotNil(t, wasmvm) + require.Equal(t, "*hostCore.vmHost", fmt.Sprintf("%T", wasmvm)) }) - t.Run("shard should NOT add systemVM", func(t *testing.T) { + t.Run("regular chain should NOT add systemVM", func(t *testing.T) { t.Parallel() + args := createMockSCQueryElementArgs() - args.SystemSCConfig = &config.SystemSmartContractsConfig{ - ESDTSystemSCConfig: config.ESDTSystemSCConfig{ - BaseIssuingCost: "1000", - OwnerAddress: "erd1fpkcgel4gcmh8zqqdt043yfcn5tyx8373kg6q2qmkxzu4dqamc0swts65c", - }, - GovernanceSystemSCConfig: config.GovernanceSystemSCConfig{ - V1: config.GovernanceSystemSCConfigV1{ - ProposalCost: "500", - NumNodes: 100, - MinQuorum: 50, - MinPassThreshold: 50, - MinVetoThreshold: 50, - }, - Active: config.GovernanceSystemSCConfigActive{ - ProposalCost: "500", - MinQuorum: 0.5, - MinPassThreshold: 0.5, - MinVetoThreshold: 0.5, - }, - OwnerAddress: "erd1vxy22x0fj4zv6hktmydg8vpfh6euv02cz4yg0aaws6rrad5a5awqgqky80", - }, - StakingSystemSCConfig: config.StakingSystemSCConfig{ - GenesisNodePrice: "2500000000000000000000", - MinStakeValue: "1", - UnJailValue: "1", - MinStepValue: "1", - UnBondPeriod: 0, - NumRoundsWithoutBleed: 0, - MaximumPercentageToBleed: 0, - BleedPercentagePerRound: 0, - MaxNumberOfNodesForStake: 10, - ActivateBLSPubKeyMessageVerification: false, - MinUnstakeTokensValue: "1", - }, - DelegationManagerSystemSCConfig: config.DelegationManagerSystemSCConfig{ - MinCreationDeposit: "100", - MinStakeAmount: "100", - ConfigChangeAddress: "erd1vxy22x0fj4zv6hktmydg8vpfh6euv02cz4yg0aaws6rrad5a5awqgqky80", - }, - DelegationSystemSCConfig: config.DelegationSystemSCConfig{ - MinServiceFee: 0, - MaxServiceFee: 100, - }, - } args.ChainRunType = common.ChainRunTypeRegular argsScQueryService, err := api.CreateArgsSCQueryService(args) @@ -576,5 +538,10 @@ func TestCreateApiResolver_createArgsSCQueryService(t *testing.T) { svm, err := argsScQueryService.VmContainer.Get(vmFactory.SystemVirtualMachine) require.NotNil(t, err) require.Nil(t, svm) + + wasmvm, err := argsScQueryService.VmContainer.Get(vmFactory.WasmVirtualMachine) + require.Nil(t, err) + require.NotNil(t, wasmvm) + require.Equal(t, "*hostCore.vmHost", fmt.Sprintf("%T", wasmvm)) }) } diff --git a/factory/api/export_test.go b/factory/api/export_test.go index 6e1197969eb..059bd778880 100644 --- a/factory/api/export_test.go +++ b/factory/api/export_test.go @@ -52,8 +52,8 @@ func CreateScQueryElement(args SCQueryElementArgs) (process.SCQueryService, erro }) } -// CreateArgsSCQueryService - create the args for SC Query Service -func CreateArgsSCQueryService(args SCQueryElementArgs) (smartContract.ArgsNewSCQueryService, error) { +// CreateArgsSCQueryService - +func CreateArgsSCQueryService(args SCQueryElementArgs) (*smartContract.ArgsNewSCQueryService, error) { return createArgsSCQueryService(&scQueryElementArgs{ generalConfig: args.GeneralConfig, epochConfig: args.EpochConfig, From 5217abc3e15f49604e2925f7bddd80f3c50f8457 Mon Sep 17 00:00:00 2001 From: axenteoctavian Date: Fri, 12 Jan 2024 16:40:28 +0200 Subject: [PATCH 34/56] fixes after review --- factory/api/apiResolverFactory.go | 7 +------ 1 file changed, 1 insertion(+), 6 deletions(-) diff --git a/factory/api/apiResolverFactory.go b/factory/api/apiResolverFactory.go index 8fc260dcedb..4245c42cde6 100644 --- a/factory/api/apiResolverFactory.go +++ b/factory/api/apiResolverFactory.go @@ -527,12 +527,7 @@ func addSystemVMToContainerIfNeeded(args *scQueryElementArgs, vmContainer proces return err } - err = vmContainer.Add(processFactory.SystemVirtualMachine, vmMeta) - if err != nil { - return err - } - - return nil + return vmContainer.Add(processFactory.SystemVirtualMachine, vmMeta) } func createMetaVmContainerFactory(args *scQueryElementArgs, argsHook hooks.ArgBlockChainHook) (process.VirtualMachinesContainerFactory, error) { From a03e3f8a676584295b218d5f31cad4e435cc98dc Mon Sep 17 00:00:00 2001 From: Octavian Axente <45915201+axenteoctavian@users.noreply.github.com> Date: Mon, 15 Jan 2024 12:54:26 +0200 Subject: [PATCH 35/56] fix wrongfully formatted file --- facade/nodeFacade.go | 6 ++---- 1 file changed, 2 insertions(+), 4 deletions(-) diff --git a/facade/nodeFacade.go b/facade/nodeFacade.go index e2229cbd5c9..e1e9a307549 100644 --- a/facade/nodeFacade.go +++ b/facade/nodeFacade.go @@ -37,8 +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") @@ -165,8 +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 From ac43195a26edc27cbe2a9476a36a280b3bac1164 Mon Sep 17 00:00:00 2001 From: Octavian Axente <45915201+axenteoctavian@users.noreply.github.com> Date: Mon, 15 Jan 2024 12:55:36 +0200 Subject: [PATCH 36/56] errorsMx go import --- facade/nodeFacade_test.go | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/facade/nodeFacade_test.go b/facade/nodeFacade_test.go index 4e52c8141fe..be9ed3f71e3 100644 --- a/facade/nodeFacade_test.go +++ b/facade/nodeFacade_test.go @@ -22,7 +22,7 @@ import ( "github.com/multiversx/mx-chain-go/common" "github.com/multiversx/mx-chain-go/config" "github.com/multiversx/mx-chain-go/debug" - globalErrors "github.com/multiversx/mx-chain-go/errors" + 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" @@ -85,7 +85,7 @@ func TestNewNodeFacade(t *testing.T) { nf, err := NewNodeFacade(arg) require.Nil(t, nf) - require.Equal(t, globalErrors.ErrNilNode, err) + require.Equal(t, errorsMx.ErrNilNode, err) }) t.Run("nil ApiResolver should error", func(t *testing.T) { t.Parallel() From fddc8090da90fb5956dbedf694aed13d7b974db8 Mon Sep 17 00:00:00 2001 From: Octavian Axente <45915201+axenteoctavian@users.noreply.github.com> Date: Mon, 15 Jan 2024 13:00:13 +0200 Subject: [PATCH 37/56] IsInterfaceNil in sovereignNode --- node/sovereignNode.go | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/node/sovereignNode.go b/node/sovereignNode.go index 0896e6c5f1c..efc3aba2419 100644 --- a/node/sovereignNode.go +++ b/node/sovereignNode.go @@ -80,3 +80,8 @@ func (sn *sovereignNode) GetESDTsRoles(address string, options api.AccountQueryO return tokensRoles, blockInfo, nil } + +// IsInterfaceNil returns true if there is no value under the interface +func (sn *sovereignNode) IsInterfaceNil() bool { + return n == nil +} From 5e9ccdb6c382172b8b4787ecb525033e7d7c3469 Mon Sep 17 00:00:00 2001 From: Octavian Axente <45915201+axenteoctavian@users.noreply.github.com> Date: Mon, 15 Jan 2024 13:00:53 +0200 Subject: [PATCH 38/56] use IsInterfaceNil func Co-authored-by: mariusmihaic <82832880+mariusmihaic@users.noreply.github.com> --- node/sovereignNode_test.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/node/sovereignNode_test.go b/node/sovereignNode_test.go index 28e1af357c5..8e0a5b4e119 100644 --- a/node/sovereignNode_test.go +++ b/node/sovereignNode_test.go @@ -21,7 +21,7 @@ func TestNewSovereignNode(t *testing.T) { sn, err := node.NewSovereignNode(n) require.Nil(t, err) - require.NotNil(t, sn) + require.False(t, sn.IsInterfaceNil()) }) t.Run("nil node should error", func(t *testing.T) { t.Parallel() From 0e5cb551e2dcc82c8832d1deb0aad84e6fec923e Mon Sep 17 00:00:00 2001 From: Octavian Axente <45915201+axenteoctavian@users.noreply.github.com> Date: Mon, 15 Jan 2024 13:03:26 +0200 Subject: [PATCH 39/56] Update node_test.go --- node/node_test.go | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/node/node_test.go b/node/node_test.go index ad39ed412b5..bac50b4ea1e 100644 --- a/node/node_test.go +++ b/node/node_test.go @@ -1363,8 +1363,8 @@ func TestNode_GetESDTsWithRole_WrongChainId(t *testing.T) { node.WithProcessComponents(processComponents)) require.Nil(t, err) - testResult, _, err := n.GetESDTsWithRole(testscommon.TestAddressAlice, core.ESDTRoleNFTCreate, api.AccountQueryOptions{}, context.Background()) - require.Nil(t, testResult) + res, _, err := n.GetESDTsWithRole(testscommon.TestAddressAlice, core.ESDTRoleNFTCreate, api.AccountQueryOptions{}, context.Background()) + require.Nil(t, res) require.Equal(t, node.ErrMetachainOnlyEndpoint, err) } From 3c25bae1cc1ed3a82d519e6a9da03b699427f0e3 Mon Sep 17 00:00:00 2001 From: Octavian Axente <45915201+axenteoctavian@users.noreply.github.com> Date: Mon, 15 Jan 2024 13:36:36 +0200 Subject: [PATCH 40/56] fix sovereignNode.go --- node/sovereignNode.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/node/sovereignNode.go b/node/sovereignNode.go index efc3aba2419..c2758c7e80d 100644 --- a/node/sovereignNode.go +++ b/node/sovereignNode.go @@ -83,5 +83,5 @@ func (sn *sovereignNode) GetESDTsRoles(address string, options api.AccountQueryO // IsInterfaceNil returns true if there is no value under the interface func (sn *sovereignNode) IsInterfaceNil() bool { - return n == nil + return sn == nil } From 5acdcd9c43e4fe51c41928f29fb82ee396389380 Mon Sep 17 00:00:00 2001 From: Octavian Axente <45915201+axenteoctavian@users.noreply.github.com> Date: Mon, 15 Jan 2024 13:58:18 +0200 Subject: [PATCH 41/56] Update interface.go --- node/trieIterators/factory/interface.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/node/trieIterators/factory/interface.go b/node/trieIterators/factory/interface.go index 22dff265f14..02667e4770f 100644 --- a/node/trieIterators/factory/interface.go +++ b/node/trieIterators/factory/interface.go @@ -17,7 +17,7 @@ type DirectStakedListProcessorFactoryHandler interface { IsInterfaceNil() bool } -// TotalStakedValueProcessorFactoryHandler can create direct staked list processor handler +// TotalStakedValueProcessorFactoryHandler can create total staked value processor handler type TotalStakedValueProcessorFactoryHandler interface { CreateTotalStakedValueProcessorHandler(args trieIterators.ArgTrieIteratorProcessor) (external.TotalStakedValueHandler, error) IsInterfaceNil() bool From 2489acc5dc7c71782c33c6bd87db0e1de9c098d6 Mon Sep 17 00:00:00 2001 From: Octavian Axente <45915201+axenteoctavian@users.noreply.github.com> Date: Mon, 15 Jan 2024 13:58:53 +0200 Subject: [PATCH 42/56] Update sovereignStakeValuesHandlerFactory.go --- .../factory/sovereignStakeValuesHandlerFactory.go | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/node/trieIterators/factory/sovereignStakeValuesHandlerFactory.go b/node/trieIterators/factory/sovereignStakeValuesHandlerFactory.go index ed388819694..489bc1f7d6b 100644 --- a/node/trieIterators/factory/sovereignStakeValuesHandlerFactory.go +++ b/node/trieIterators/factory/sovereignStakeValuesHandlerFactory.go @@ -14,11 +14,11 @@ func NewSovereignTotalStakedValueProcessorFactory() *sovereignTotalStakedValuePr } // CreateTotalStakedValueProcessorHandler will create a new instance of total staked value processor for sovereign chain -func (d *sovereignTotalStakedValueProcessorFactory) CreateTotalStakedValueProcessorHandler(args trieIterators.ArgTrieIteratorProcessor) (external.TotalStakedValueHandler, error) { +func (f *sovereignTotalStakedValueProcessorFactory) CreateTotalStakedValueProcessorHandler(args trieIterators.ArgTrieIteratorProcessor) (external.TotalStakedValueHandler, error) { return trieIterators.NewTotalStakedValueProcessor(args) } // IsInterfaceNil checks if the underlying pointer is nil -func (d *sovereignTotalStakedValueProcessorFactory) IsInterfaceNil() bool { +func (f *sovereignTotalStakedValueProcessorFactory) IsInterfaceNil() bool { return d == nil } From 47fb64acc76a7b15cf596aab7b9d35a0a9097c82 Mon Sep 17 00:00:00 2001 From: Octavian Axente <45915201+axenteoctavian@users.noreply.github.com> Date: Mon, 15 Jan 2024 13:59:06 +0200 Subject: [PATCH 43/56] Update node/trieIterators/factory/stakeValuesHandlerFactory.go Co-authored-by: mariusmihaic <82832880+mariusmihaic@users.noreply.github.com> --- node/trieIterators/factory/stakeValuesHandlerFactory.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/node/trieIterators/factory/stakeValuesHandlerFactory.go b/node/trieIterators/factory/stakeValuesHandlerFactory.go index c7e3ff1437c..8d901cbd1ff 100644 --- a/node/trieIterators/factory/stakeValuesHandlerFactory.go +++ b/node/trieIterators/factory/stakeValuesHandlerFactory.go @@ -10,7 +10,7 @@ import ( type totalStakedValueProcessorFactory struct { } -// NewTotalStakedListProcessorFactory create a new total staked value handler +// NewTotalStakedListProcessorFactory creates a new total staked value handler func NewTotalStakedListProcessorFactory() *totalStakedValueProcessorFactory { return &totalStakedValueProcessorFactory{} } From c94f0c5655f3b9bca3aaf1808749c512c4655dd7 Mon Sep 17 00:00:00 2001 From: Octavian Axente <45915201+axenteoctavian@users.noreply.github.com> Date: Mon, 15 Jan 2024 14:01:56 +0200 Subject: [PATCH 44/56] Update sovereignStakeValuesHandlerFactory.go --- .../trieIterators/factory/sovereignStakeValuesHandlerFactory.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/node/trieIterators/factory/sovereignStakeValuesHandlerFactory.go b/node/trieIterators/factory/sovereignStakeValuesHandlerFactory.go index 489bc1f7d6b..87278599ba5 100644 --- a/node/trieIterators/factory/sovereignStakeValuesHandlerFactory.go +++ b/node/trieIterators/factory/sovereignStakeValuesHandlerFactory.go @@ -20,5 +20,5 @@ func (f *sovereignTotalStakedValueProcessorFactory) CreateTotalStakedValueProces // IsInterfaceNil checks if the underlying pointer is nil func (f *sovereignTotalStakedValueProcessorFactory) IsInterfaceNil() bool { - return d == nil + return f == nil } From 95ecd04483ddc8265032b321d1047cca03186746 Mon Sep 17 00:00:00 2001 From: Octavian Axente <45915201+axenteoctavian@users.noreply.github.com> Date: Mon, 15 Jan 2024 14:02:37 +0200 Subject: [PATCH 45/56] Update nodeRunner.go --- node/nodeRunner.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/node/nodeRunner.go b/node/nodeRunner.go index 7d1ba7e8a73..15b1ff36310 100644 --- a/node/nodeRunner.go +++ b/node/nodeRunner.go @@ -2,7 +2,6 @@ package node import ( "fmt" - trieIteratorsFactory "github.com/multiversx/mx-chain-go/node/trieIterators/factory" "io" "math/big" "os" @@ -56,6 +55,7 @@ import ( genesisProcess "github.com/multiversx/mx-chain-go/genesis/process" "github.com/multiversx/mx-chain-go/health" "github.com/multiversx/mx-chain-go/node/metrics" + trieIteratorsFactory "github.com/multiversx/mx-chain-go/node/trieIterators/factory" "github.com/multiversx/mx-chain-go/outport" "github.com/multiversx/mx-chain-go/process" "github.com/multiversx/mx-chain-go/process/block/preprocess" From 48ab8e73bdc1a233bbde784b113d72c3cd4cb8b9 Mon Sep 17 00:00:00 2001 From: axenteoctavian Date: Mon, 15 Jan 2024 16:12:20 +0200 Subject: [PATCH 46/56] fixes after review --- factory/api/apiResolverFactory.go | 16 ++++------- factory/api/apiResolverFactory_test.go | 38 +++++++++++++++++++------- 2 files changed, 33 insertions(+), 21 deletions(-) diff --git a/factory/api/apiResolverFactory.go b/factory/api/apiResolverFactory.go index 4245c42cde6..2a6cfffe304 100644 --- a/factory/api/apiResolverFactory.go +++ b/factory/api/apiResolverFactory.go @@ -416,38 +416,32 @@ func createArgsSCQueryService(args *scQueryElementArgs) (*smartContract.ArgsNewS MissingTrieNodesNotifier: syncer.NewMissingTrieNodesNotifier(), } - var apiBlockchain data.ChainHandler - var accAdapter state.AccountsAdapterAPI var vmFactory process.VirtualMachinesContainerFactory maxGasForVmQueries := args.generalConfig.VirtualMachine.GasConfig.ShardMaxGasPerVmQuery if args.processComponents.ShardCoordinator().SelfId() == core.MetachainShardId { maxGasForVmQueries = args.generalConfig.VirtualMachine.GasConfig.MetaMaxGasPerVmQuery - apiBlockchain, err = blockchain.NewMetaChain(disabled.NewAppStatusHandler()) + argsHook.BlockChain, err = blockchain.NewMetaChain(disabled.NewAppStatusHandler()) if err != nil { return nil, err } - argsHook.BlockChain = apiBlockchain - accAdapter, err = createNewAccountsAdapterApi(args, apiBlockchain) + argsHook.Accounts, err = createNewAccountsAdapterApi(args, argsHook.BlockChain) if err != nil { return nil, err } - argsHook.Accounts = accAdapter vmFactory, err = createMetaVmContainerFactory(args, argsHook) } else { - apiBlockchain, err = blockchain.NewBlockChain(disabled.NewAppStatusHandler()) + argsHook.BlockChain, err = blockchain.NewBlockChain(disabled.NewAppStatusHandler()) if err != nil { return nil, err } - argsHook.BlockChain = apiBlockchain - accAdapter, err = createNewAccountsAdapterApi(args, apiBlockchain) + argsHook.Accounts, err = createNewAccountsAdapterApi(args, argsHook.BlockChain) if err != nil { return nil, err } - argsHook.Accounts = accAdapter vmFactory, err = createShardVmContainerFactory(args, argsHook) } @@ -482,7 +476,7 @@ func createArgsSCQueryService(args *scQueryElementArgs) (*smartContract.ArgsNewS EconomicsFee: args.coreComponents.EconomicsData(), BlockChainHook: vmFactory.BlockChainHookImpl(), MainBlockChain: args.dataComponents.Blockchain(), - APIBlockChain: apiBlockchain, + APIBlockChain: argsHook.BlockChain, WasmVMChangeLocker: args.coreComponents.WasmVMChangeLocker(), Bootstrapper: args.bootstrapper, AllowExternalQueriesChan: args.allowVMQueriesChan, diff --git a/factory/api/apiResolverFactory_test.go b/factory/api/apiResolverFactory_test.go index 25b29965ecf..d0916752f85 100644 --- a/factory/api/apiResolverFactory_test.go +++ b/factory/api/apiResolverFactory_test.go @@ -287,7 +287,7 @@ func TestCreateApiResolver(t *testing.T) { }) } -func createMockSCQueryElementArgs() api.SCQueryElementArgs { +func createMockSCQueryElementArgs(shardId uint32) api.SCQueryElementArgs { return api.SCQueryElementArgs{ GeneralConfig: &config.Config{ BuiltInFunctions: config.BuiltInFunctionsConfig{ @@ -356,7 +356,9 @@ func createMockSCQueryElementArgs() api.SCQueryElementArgs { DataPool: &dataRetriever.PoolsHolderMock{}, }, ProcessComponents: &mock.ProcessComponentsMock{ - ShardCoord: &testscommon.ShardsCoordinatorMock{}, + ShardCoord: &testscommon.ShardsCoordinatorMock{ + CurrentShard: shardId, + }, }, GasScheduleNotifier: &testscommon.GasScheduleNotifierMock{ LatestGasScheduleCalled: func() map[string]map[string]uint64 { @@ -424,7 +426,7 @@ func TestCreateApiResolver_createScQueryElement(t *testing.T) { t.Run("nil guardian handler should error", func(t *testing.T) { t.Parallel() - args := createMockSCQueryElementArgs() + args := createMockSCQueryElementArgs(0) args.GuardedAccountHandler = nil scQueryService, err := api.CreateScQueryElement(args) require.Equal(t, process.ErrNilGuardedAccountHandler, err) @@ -433,7 +435,7 @@ func TestCreateApiResolver_createScQueryElement(t *testing.T) { t.Run("DecodeAddresses fails", func(t *testing.T) { t.Parallel() - args := createMockSCQueryElementArgs() + args := createMockSCQueryElementArgs(0) args.CoreComponents = &mock.CoreComponentsMock{ AddrPubKeyConv: nil, } @@ -445,7 +447,7 @@ func TestCreateApiResolver_createScQueryElement(t *testing.T) { t.Run("createBuiltinFuncs fails", func(t *testing.T) { t.Parallel() - args := createMockSCQueryElementArgs() + args := createMockSCQueryElementArgs(0) coreCompMock := args.CoreComponents.(*mock.CoreComponentsMock) coreCompMock.IntMarsh = nil scQueryService, err := api.CreateScQueryElement(args) @@ -456,7 +458,7 @@ func TestCreateApiResolver_createScQueryElement(t *testing.T) { t.Run("NewCache fails", func(t *testing.T) { t.Parallel() - args := createMockSCQueryElementArgs() + args := createMockSCQueryElementArgs(0) args.GeneralConfig.SmartContractDataPool = config.CacheConfig{ Type: "LRU", SizeInBytes: 1, @@ -469,7 +471,7 @@ func TestCreateApiResolver_createScQueryElement(t *testing.T) { t.Run("metachain - NewVMContainerFactory fails", func(t *testing.T) { t.Parallel() - args := createMockSCQueryElementArgs() + args := createMockSCQueryElementArgs(0) args.ProcessComponents = &mock.ProcessComponentsMock{ ShardCoord: &testscommon.ShardsCoordinatorMock{ SelfIDCalled: func() uint32 { @@ -487,7 +489,7 @@ func TestCreateApiResolver_createScQueryElement(t *testing.T) { t.Run("shard - NewVMContainerFactory fails", func(t *testing.T) { t.Parallel() - args := createMockSCQueryElementArgs() + args := createMockSCQueryElementArgs(0) coreCompMock := args.CoreComponents.(*mock.CoreComponentsMock) coreCompMock.Hash = nil scQueryService, err := api.CreateScQueryElement(args) @@ -504,7 +506,7 @@ func TestCreateApiResolver_createArgsSCQueryService(t *testing.T) { t.Run("sovereign chain should add systemVM", func(t *testing.T) { t.Parallel() - args := createMockSCQueryElementArgs() + args := createMockSCQueryElementArgs(0) args.ChainRunType = common.ChainRunTypeSovereign argsScQueryService, err := api.CreateArgsSCQueryService(args) @@ -526,7 +528,7 @@ func TestCreateApiResolver_createArgsSCQueryService(t *testing.T) { t.Run("regular chain should NOT add systemVM", func(t *testing.T) { t.Parallel() - args := createMockSCQueryElementArgs() + args := createMockSCQueryElementArgs(0) args.ChainRunType = common.ChainRunTypeRegular argsScQueryService, err := api.CreateArgsSCQueryService(args) @@ -544,4 +546,20 @@ func TestCreateApiResolver_createArgsSCQueryService(t *testing.T) { require.NotNil(t, wasmvm) require.Equal(t, "*hostCore.vmHost", fmt.Sprintf("%T", wasmvm)) }) + t.Run("metachain chain should NOT add systemVM", func(t *testing.T) { + t.Parallel() + + args := createMockSCQueryElementArgs(common.MetachainShardId) + args.ChainRunType = common.MetachainShardName + + argsScQueryService, err := api.CreateArgsSCQueryService(args) + require.Nil(t, err) + require.NotNil(t, argsScQueryService.VmContainer) + + require.Equal(t, 1, argsScQueryService.VmContainer.Len()) + + svm, err := argsScQueryService.VmContainer.Get(vmFactory.SystemVirtualMachine) + require.Nil(t, err) + require.NotNil(t, svm) + }) } From c3d2adb4d837ede24e676927772f2653da8819d9 Mon Sep 17 00:00:00 2001 From: axenteoctavian Date: Mon, 15 Jan 2024 16:33:17 +0200 Subject: [PATCH 47/56] fixes after review --- ...een.sh => deployFullStackSovereignChainWithScreen.sh} | 0 scripts/testnet/include/config.sh | 9 +++------ scripts/testnet/variables.sh | 2 -- 3 files changed, 3 insertions(+), 8 deletions(-) rename scripts/testnet/{deploySovereignScreen.sh => deployFullStackSovereignChainWithScreen.sh} (100%) diff --git a/scripts/testnet/deploySovereignScreen.sh b/scripts/testnet/deployFullStackSovereignChainWithScreen.sh similarity index 100% rename from scripts/testnet/deploySovereignScreen.sh rename to scripts/testnet/deployFullStackSovereignChainWithScreen.sh diff --git a/scripts/testnet/include/config.sh b/scripts/testnet/include/config.sh index b92677919c3..d1f003d8af3 100644 --- a/scripts/testnet/include/config.sh +++ b/scripts/testnet/include/config.sh @@ -8,9 +8,9 @@ generateConfig() { TMP_META_OBSERVERCOUNT=0 fi - SOVEREIGN_BOOL="false" + SOVEREIGN_DEPLOY=0 if [ $USE_HARDFORK -eq 1 ]; then - SOVEREIGN_BOOL="true" + SOVEREIGN_DEPLOY=1 fi pushd $TESTNETDIR/filegen @@ -26,7 +26,7 @@ generateConfig() { -stake-type $GENESIS_STAKE_TYPE \ -hysteresis $HYSTERESIS \ -round-duration $ROUND_DURATION \ - -sovereign=$SOVEREIGN_BOOL + -sovereign=SOVEREIGN_DEPLOY popd } @@ -249,9 +249,6 @@ updateTxGenConfig() { updateSovereignTxGenConfig() { updateTxGenConfig pushd $TESTNETDIR/txgen/config/nodeConfig/config - updateTOMLValue enableEpochs.toml "SCDeployEnableEpoch" 0 - updateTOMLValue enableEpochs.toml "BuiltInFunctionsEnableEpoch" 0 - updateTOMLValue enableEpochs.toml "ESDTEnableEpoch" 0 } generateProxyObserverList() { diff --git a/scripts/testnet/variables.sh b/scripts/testnet/variables.sh index 20ca6f06cd4..8195e633dc0 100644 --- a/scripts/testnet/variables.sh +++ b/scripts/testnet/variables.sh @@ -65,8 +65,6 @@ export OBSERVERS_ANTIFLOOD_DISABLE=0 # For now, make sure that you checkout feat/sovereign branch from mx-chain-deploy repo when using these scripts export SOVEREIGN_DEPLOY=1 -export ROUND_DURATION=4000 - # Shard structure export SHARDCOUNT=1 export SHARD_VALIDATORCOUNT=3 From b230c10045603c2d974047fabace69ac94528416 Mon Sep 17 00:00:00 2001 From: Octavian Axente <45915201+axenteoctavian@users.noreply.github.com> Date: Mon, 15 Jan 2024 17:09:46 +0200 Subject: [PATCH 48/56] Update factory/api/apiResolverFactory_test.go Co-authored-by: mariusmihaic <82832880+mariusmihaic@users.noreply.github.com> --- factory/api/apiResolverFactory_test.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/factory/api/apiResolverFactory_test.go b/factory/api/apiResolverFactory_test.go index d0916752f85..4fbd4801488 100644 --- a/factory/api/apiResolverFactory_test.go +++ b/factory/api/apiResolverFactory_test.go @@ -525,7 +525,7 @@ func TestCreateApiResolver_createArgsSCQueryService(t *testing.T) { require.NotNil(t, wasmvm) require.Equal(t, "*hostCore.vmHost", fmt.Sprintf("%T", wasmvm)) }) - t.Run("regular chain should NOT add systemVM", func(t *testing.T) { + t.Run("regular chain for shards should only add wasm vm", func(t *testing.T) { t.Parallel() args := createMockSCQueryElementArgs(0) From 063d2c33d92f5ff5bed383d6c02b6a904fe3069a Mon Sep 17 00:00:00 2001 From: Octavian Axente <45915201+axenteoctavian@users.noreply.github.com> Date: Mon, 15 Jan 2024 17:09:53 +0200 Subject: [PATCH 49/56] Update factory/api/apiResolverFactory_test.go Co-authored-by: mariusmihaic <82832880+mariusmihaic@users.noreply.github.com> --- factory/api/apiResolverFactory_test.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/factory/api/apiResolverFactory_test.go b/factory/api/apiResolverFactory_test.go index 4fbd4801488..b2dd8fa9a32 100644 --- a/factory/api/apiResolverFactory_test.go +++ b/factory/api/apiResolverFactory_test.go @@ -546,7 +546,7 @@ func TestCreateApiResolver_createArgsSCQueryService(t *testing.T) { require.NotNil(t, wasmvm) require.Equal(t, "*hostCore.vmHost", fmt.Sprintf("%T", wasmvm)) }) - t.Run("metachain chain should NOT add systemVM", func(t *testing.T) { + t.Run("regular chain for meta should only add systemVM", func(t *testing.T) { t.Parallel() args := createMockSCQueryElementArgs(common.MetachainShardId) From 4446184002248534de42006ecbe8ea55fb788a46 Mon Sep 17 00:00:00 2001 From: axenteoctavian Date: Tue, 16 Jan 2024 10:42:27 +0200 Subject: [PATCH 50/56] added test and the necessary mocks --- node/mock/factory/consensusComponentsMock.go | 65 ++++++++++++++++++ node/mock/factory/networkComponentsMock.go | 3 +- node/nodeHelper_test.go | 68 +++++++++++++------ node/nodeTesting_test.go | 30 ++++++-- node/node_test.go | 8 ++- .../mainFactoryMocks/statusComponentsStub.go | 16 +++++ 6 files changed, 164 insertions(+), 26 deletions(-) create mode 100644 node/mock/factory/consensusComponentsMock.go diff --git a/node/mock/factory/consensusComponentsMock.go b/node/mock/factory/consensusComponentsMock.go new file mode 100644 index 00000000000..f56a160901a --- /dev/null +++ b/node/mock/factory/consensusComponentsMock.go @@ -0,0 +1,65 @@ +package factory + +import ( + "github.com/multiversx/mx-chain-go/consensus" + "github.com/multiversx/mx-chain-go/factory" + "github.com/multiversx/mx-chain-go/process" +) + +type ConsensusComponentsStub struct { + ChronologyHandler consensus.ChronologyHandler + ConsensusWorkerHandler factory.ConsensusWorker + BroadcastMessengerHandler consensus.BroadcastMessenger + GroupSize int + BootstrapperHandler process.Bootstrapper +} + +// Create - +func (ccs *ConsensusComponentsStub) Create() error { + return nil +} + +// Close - +func (ccs *ConsensusComponentsStub) Close() error { + return nil +} + +// CheckSubcomponents - +func (ccs *ConsensusComponentsStub) CheckSubcomponents() error { + return nil +} + +// String - +func (ccs *ConsensusComponentsStub) String() string { + return "ConsensusComponentsMock" +} + +// Chronology - +func (ccs *ConsensusComponentsStub) Chronology() consensus.ChronologyHandler { + return ccs.ChronologyHandler +} + +// ConsensusWorker - +func (ccs *ConsensusComponentsStub) ConsensusWorker() factory.ConsensusWorker { + return ccs.ConsensusWorkerHandler +} + +// BroadcastMessenger - +func (ccs *ConsensusComponentsStub) BroadcastMessenger() consensus.BroadcastMessenger { + return ccs.BroadcastMessengerHandler +} + +// Bootstrapper - +func (ccs *ConsensusComponentsStub) Bootstrapper() process.Bootstrapper { + return ccs.BootstrapperHandler +} + +// ConsensusGroupSize - +func (ccs *ConsensusComponentsStub) ConsensusGroupSize() (int, error) { + return ccs.GroupSize, nil +} + +// IsInterfaceNil - +func (ccs *ConsensusComponentsStub) IsInterfaceNil() bool { + return ccs == nil +} diff --git a/node/mock/factory/networkComponentsMock.go b/node/mock/factory/networkComponentsMock.go index 88acf5468ea..0088ae52cab 100644 --- a/node/mock/factory/networkComponentsMock.go +++ b/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 - diff --git a/node/nodeHelper_test.go b/node/nodeHelper_test.go index 43f613cf0db..6b538a59d67 100644 --- a/node/nodeHelper_test.go +++ b/node/nodeHelper_test.go @@ -1,6 +1,7 @@ package node_test import ( + "github.com/multiversx/mx-chain-go/testscommon/mainFactoryMocks" "testing" "github.com/multiversx/mx-chain-go/config" @@ -12,24 +13,51 @@ import ( func TestCreateNode(t *testing.T) { t.Parallel() - nodeHandler, err := node.CreateNode( - &config.Config{}, - nil, - getDefaultBootstrapComponents(), - getDefaultCoreComponents(), - getDefaultCryptoComponents(), - getDefaultDataComponents(), - getDefaultNetworkComponents(), - getDefaultProcessComponents(), - getDefaultStateComponents(), - nil, - nil, - nil, - 0, - false, - nil) - - require.NotNil(t, err) - require.Equal(t, errors.ErrNilNode, err) - require.Nil(t, nodeHandler) + t.Run("nil node factory should not work", func(t *testing.T) { + t.Parallel() + + nodeHandler, err := node.CreateNode( + &config.Config{}, + getDefaultStatusCoreComponents(), + getDefaultBootstrapComponents(), + getDefaultCoreComponents(), + getDefaultCryptoComponents(), + getDefaultDataComponents(), + getDefaultNetworkComponents(), + getDefaultProcessComponents(), + getDefaultStateComponents(), + getDefaultStatusComponents(), + getDefaultHeartbeatV2Components(), + getDefaultConsensusComponents(), + 0, + false, + nil) + + require.NotNil(t, err) + require.Equal(t, errors.ErrNilNode, err) + require.Nil(t, nodeHandler) + }) + t.Run("should work", func(t *testing.T) { + t.Parallel() + + nodeHandler, err := node.CreateNode( + &config.Config{}, + getDefaultStatusCoreComponents(), + getDefaultBootstrapComponents(), + getDefaultCoreComponents(), + getDefaultCryptoComponents(), + getDefaultDataComponents(), + getDefaultNetworkComponents(), + getDefaultProcessComponents(), + getDefaultStateComponents(), + &mainFactoryMocks.StatusComponentsStub{}, + getDefaultHeartbeatV2Components(), + getDefaultConsensusComponents(), + 0, + false, + node.NewSovereignNodeFactory()) + + require.Nil(t, err) + require.NotNil(t, nodeHandler) + }) } diff --git a/node/nodeTesting_test.go b/node/nodeTesting_test.go index 8718ea5c8ea..06a8b80fdb5 100644 --- a/node/nodeTesting_test.go +++ b/node/nodeTesting_test.go @@ -13,6 +13,7 @@ import ( crypto "github.com/multiversx/mx-chain-crypto-go" "github.com/multiversx/mx-chain-go/common" "github.com/multiversx/mx-chain-go/dataRetriever" + mocks "github.com/multiversx/mx-chain-go/factory/mock" "github.com/multiversx/mx-chain-go/node" "github.com/multiversx/mx-chain-go/node/mock" factoryMock "github.com/multiversx/mx-chain-go/node/mock/factory" @@ -22,6 +23,7 @@ import ( "github.com/multiversx/mx-chain-go/testscommon/cryptoMocks" dataRetrieverMock "github.com/multiversx/mx-chain-go/testscommon/dataRetriever" factoryMocks "github.com/multiversx/mx-chain-go/testscommon/factory" + "github.com/multiversx/mx-chain-go/testscommon/mainFactoryMocks" "github.com/multiversx/mx-chain-go/testscommon/p2pmocks" stateMock "github.com/multiversx/mx-chain-go/testscommon/state" "github.com/multiversx/mx-chain-go/testscommon/storageManager" @@ -422,9 +424,29 @@ func getDefaultStateComponents() *factoryMocks.StateComponentsMock { func getDefaultNetworkComponents() *factoryMock.NetworkComponentsMock { return &factoryMock.NetworkComponentsMock{ - Messenger: &p2pmocks.MessengerStub{}, - InputAntiFlood: &mock.P2PAntifloodHandlerStub{}, - OutputAntiFlood: &mock.P2PAntifloodHandlerStub{}, - PeerBlackList: &mock.PeerBlackListHandlerStub{}, + Messenger: &p2pmocks.MessengerStub{}, + InputAntiFlood: &mock.P2PAntifloodHandlerStub{}, + OutputAntiFlood: &mock.P2PAntifloodHandlerStub{}, + PeerBlackList: &mock.PeerBlackListHandlerStub{}, + PubKeyCacherField: &testscommon.TimeCacheStub{}, + FullArchiveNetworkMessengerField: &p2pmocks.MessengerStub{}, + } +} + +func getDefaultStatusCoreComponents() *factoryMocks.StatusCoreComponentsStub { + return &factoryMocks.StatusCoreComponentsStub{} +} + +func getDefaultStatusComponents() *mainFactoryMocks.StatusComponentsStub { + return &mainFactoryMocks.StatusComponentsStub{} +} + +func getDefaultHeartbeatV2Components() *mocks.HeartbeatV2ComponentsStub { + return &mocks.HeartbeatV2ComponentsStub{} +} + +func getDefaultConsensusComponents() *factoryMock.ConsensusComponentsStub { + return &factoryMock.ConsensusComponentsStub{ + GroupSize: 1, } } diff --git a/node/node_test.go b/node/node_test.go index ad39ed412b5..138b7e7a5bb 100644 --- a/node/node_test.go +++ b/node/node_test.go @@ -22,6 +22,7 @@ import ( "github.com/multiversx/mx-chain-core-go/data" "github.com/multiversx/mx-chain-core-go/data/api" "github.com/multiversx/mx-chain-core-go/data/block" + "github.com/multiversx/mx-chain-core-go/data/endProcess" "github.com/multiversx/mx-chain-core-go/data/esdt" "github.com/multiversx/mx-chain-core-go/data/guardians" "github.com/multiversx/mx-chain-core-go/data/transaction" @@ -5167,6 +5168,7 @@ func getDefaultCoreComponents() *nodeMockFactory.CoreComponentsMock { StartTime: time.Time{}, EpochChangeNotifier: &epochNotifier.EpochNotifierStub{}, TxVersionCheckHandler: versioning.NewTxVersionChecker(0), + ChanStopProcess: make(chan endProcess.ArgEndProcess, 1), } } @@ -5193,6 +5195,7 @@ func getDefaultProcessComponents() *factoryMock.ProcessComponentsMock { BlockTrack: &mock.BlockTrackerStub{}, PendingMiniBlocksHdl: &mock.PendingMiniBlocksHandlerStub{}, ReqHandler: &testscommon.RequestHandlerStub{}, + RequestedItemsHandlerInternal: &testscommon.RequestedItemsHandlerStub{}, TxLogsProcess: &mock.TxLogProcessorMock{}, HeaderConstructValidator: &mock.HeaderValidatorStub{}, MainPeerMapper: &p2pmocks.NetworkShardingCollectorStub{}, @@ -5202,6 +5205,8 @@ func getDefaultProcessComponents() *factoryMock.ProcessComponentsMock { TxsSenderHandlerField: &txsSenderMock.TxsSenderHandlerMock{}, ScheduledTxsExecutionHandlerInternal: &testscommon.ScheduledTxsExecutionStub{}, HistoryRepositoryInternal: &dblookupext.HistoryRepositoryStub{}, + ESDTDataStorageHandlerForAPIInternal: &testscommon.EsdtStorageHandlerStub{}, + ResContainer: &dataRetrieverMock.ResolversContainerStub{}, } } @@ -5217,11 +5222,12 @@ func getDefaultDataComponents() *nodeMockFactory.DataComponentsMock { return []byte("root hash") }, } + dataPool := dataRetrieverMock.NewPoolsHolderMock() return &nodeMockFactory.DataComponentsMock{ BlockChain: chainHandler, Store: &mockStorage.ChainStorerStub{}, - DataPool: &dataRetrieverMock.PoolsHolderMock{}, + DataPool: dataPool, MbProvider: &mock.MiniBlocksProviderStub{}, } } diff --git a/testscommon/mainFactoryMocks/statusComponentsStub.go b/testscommon/mainFactoryMocks/statusComponentsStub.go index 9f456714b43..8c362039c09 100644 --- a/testscommon/mainFactoryMocks/statusComponentsStub.go +++ b/testscommon/mainFactoryMocks/statusComponentsStub.go @@ -5,6 +5,7 @@ import ( "github.com/multiversx/mx-chain-go/common" "github.com/multiversx/mx-chain-go/common/statistics" "github.com/multiversx/mx-chain-go/outport" + "github.com/multiversx/mx-chain-go/process" ) // StatusComponentsStub - @@ -45,6 +46,21 @@ func (scs *StatusComponentsStub) ManagedPeersMonitor() common.ManagedPeersMonito return scs.ManagedPeersMonitorField } +func (scs *StatusComponentsStub) SetForkDetector(forkDetector process.ForkDetector) error { + //TODO implement me + panic("implement me") +} + +func (scs *StatusComponentsStub) StartPolling() error { + //TODO implement me + panic("implement me") +} + +// String - +func (scs *StatusComponentsStub) String() string { + return "StatusComponentsMock" +} + // IsInterfaceNil - func (scs *StatusComponentsStub) IsInterfaceNil() bool { return scs == nil From f000c27e5a0c7e02112de61c7272415dc81e45ca Mon Sep 17 00:00:00 2001 From: axenteoctavian Date: Tue, 16 Jan 2024 12:00:32 +0200 Subject: [PATCH 51/56] fixes after review --- node/nodeHelper_test.go | 23 ++++++++++++------- node/nodeTesting_test.go | 20 ---------------- .../consensus}/consensusComponentsMock.go | 2 +- .../mainFactoryMocks/statusComponentsStub.go | 6 ++--- 4 files changed, 18 insertions(+), 33 deletions(-) rename {node/mock/factory => testscommon/consensus}/consensusComponentsMock.go (98%) diff --git a/node/nodeHelper_test.go b/node/nodeHelper_test.go index 6b538a59d67..0ed15ab2a1a 100644 --- a/node/nodeHelper_test.go +++ b/node/nodeHelper_test.go @@ -1,12 +1,15 @@ package node_test import ( - "github.com/multiversx/mx-chain-go/testscommon/mainFactoryMocks" "testing" "github.com/multiversx/mx-chain-go/config" "github.com/multiversx/mx-chain-go/errors" + "github.com/multiversx/mx-chain-go/factory/mock" "github.com/multiversx/mx-chain-go/node" + "github.com/multiversx/mx-chain-go/testscommon/consensus" + "github.com/multiversx/mx-chain-go/testscommon/factory" + "github.com/multiversx/mx-chain-go/testscommon/mainFactoryMocks" "github.com/stretchr/testify/require" ) @@ -18,7 +21,7 @@ func TestCreateNode(t *testing.T) { nodeHandler, err := node.CreateNode( &config.Config{}, - getDefaultStatusCoreComponents(), + &factory.StatusCoreComponentsStub{}, getDefaultBootstrapComponents(), getDefaultCoreComponents(), getDefaultCryptoComponents(), @@ -26,9 +29,11 @@ func TestCreateNode(t *testing.T) { getDefaultNetworkComponents(), getDefaultProcessComponents(), getDefaultStateComponents(), - getDefaultStatusComponents(), - getDefaultHeartbeatV2Components(), - getDefaultConsensusComponents(), + &mainFactoryMocks.StatusComponentsStub{}, + &mock.HeartbeatV2ComponentsStub{}, + &consensus.ConsensusComponentsStub{ + GroupSize: 1, + }, 0, false, nil) @@ -42,7 +47,7 @@ func TestCreateNode(t *testing.T) { nodeHandler, err := node.CreateNode( &config.Config{}, - getDefaultStatusCoreComponents(), + &factory.StatusCoreComponentsStub{}, getDefaultBootstrapComponents(), getDefaultCoreComponents(), getDefaultCryptoComponents(), @@ -51,8 +56,10 @@ func TestCreateNode(t *testing.T) { getDefaultProcessComponents(), getDefaultStateComponents(), &mainFactoryMocks.StatusComponentsStub{}, - getDefaultHeartbeatV2Components(), - getDefaultConsensusComponents(), + &mock.HeartbeatV2ComponentsStub{}, + &consensus.ConsensusComponentsStub{ + GroupSize: 1, + }, 0, false, node.NewSovereignNodeFactory()) diff --git a/node/nodeTesting_test.go b/node/nodeTesting_test.go index 06a8b80fdb5..7ab5f644161 100644 --- a/node/nodeTesting_test.go +++ b/node/nodeTesting_test.go @@ -13,7 +13,6 @@ import ( crypto "github.com/multiversx/mx-chain-crypto-go" "github.com/multiversx/mx-chain-go/common" "github.com/multiversx/mx-chain-go/dataRetriever" - mocks "github.com/multiversx/mx-chain-go/factory/mock" "github.com/multiversx/mx-chain-go/node" "github.com/multiversx/mx-chain-go/node/mock" factoryMock "github.com/multiversx/mx-chain-go/node/mock/factory" @@ -23,7 +22,6 @@ import ( "github.com/multiversx/mx-chain-go/testscommon/cryptoMocks" dataRetrieverMock "github.com/multiversx/mx-chain-go/testscommon/dataRetriever" factoryMocks "github.com/multiversx/mx-chain-go/testscommon/factory" - "github.com/multiversx/mx-chain-go/testscommon/mainFactoryMocks" "github.com/multiversx/mx-chain-go/testscommon/p2pmocks" stateMock "github.com/multiversx/mx-chain-go/testscommon/state" "github.com/multiversx/mx-chain-go/testscommon/storageManager" @@ -432,21 +430,3 @@ func getDefaultNetworkComponents() *factoryMock.NetworkComponentsMock { FullArchiveNetworkMessengerField: &p2pmocks.MessengerStub{}, } } - -func getDefaultStatusCoreComponents() *factoryMocks.StatusCoreComponentsStub { - return &factoryMocks.StatusCoreComponentsStub{} -} - -func getDefaultStatusComponents() *mainFactoryMocks.StatusComponentsStub { - return &mainFactoryMocks.StatusComponentsStub{} -} - -func getDefaultHeartbeatV2Components() *mocks.HeartbeatV2ComponentsStub { - return &mocks.HeartbeatV2ComponentsStub{} -} - -func getDefaultConsensusComponents() *factoryMock.ConsensusComponentsStub { - return &factoryMock.ConsensusComponentsStub{ - GroupSize: 1, - } -} diff --git a/node/mock/factory/consensusComponentsMock.go b/testscommon/consensus/consensusComponentsMock.go similarity index 98% rename from node/mock/factory/consensusComponentsMock.go rename to testscommon/consensus/consensusComponentsMock.go index f56a160901a..376b29121b4 100644 --- a/node/mock/factory/consensusComponentsMock.go +++ b/testscommon/consensus/consensusComponentsMock.go @@ -1,4 +1,4 @@ -package factory +package consensus import ( "github.com/multiversx/mx-chain-go/consensus" diff --git a/testscommon/mainFactoryMocks/statusComponentsStub.go b/testscommon/mainFactoryMocks/statusComponentsStub.go index 8c362039c09..26dbdbed3c0 100644 --- a/testscommon/mainFactoryMocks/statusComponentsStub.go +++ b/testscommon/mainFactoryMocks/statusComponentsStub.go @@ -47,13 +47,11 @@ func (scs *StatusComponentsStub) ManagedPeersMonitor() common.ManagedPeersMonito } func (scs *StatusComponentsStub) SetForkDetector(forkDetector process.ForkDetector) error { - //TODO implement me - panic("implement me") + return nil } func (scs *StatusComponentsStub) StartPolling() error { - //TODO implement me - panic("implement me") + return nil } // String - From d094c2eb051f57469ccdd0bc2b6d4988c2fc8df2 Mon Sep 17 00:00:00 2001 From: axenteoctavian Date: Tue, 16 Jan 2024 12:02:56 +0200 Subject: [PATCH 52/56] fixes after review --- scripts/testnet/include/config.sh | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/scripts/testnet/include/config.sh b/scripts/testnet/include/config.sh index d1f003d8af3..02ab854b69a 100644 --- a/scripts/testnet/include/config.sh +++ b/scripts/testnet/include/config.sh @@ -25,8 +25,7 @@ generateConfig() { -metachain-consensus-group-size $META_CONSENSUS_SIZE \ -stake-type $GENESIS_STAKE_TYPE \ -hysteresis $HYSTERESIS \ - -round-duration $ROUND_DURATION \ - -sovereign=SOVEREIGN_DEPLOY + -sovereign=$SOVEREIGN_DEPLOY popd } From aafd9328baf50628d6dbc393b5b3947c3401c905 Mon Sep 17 00:00:00 2001 From: axenteoctavian Date: Tue, 16 Jan 2024 13:42:05 +0200 Subject: [PATCH 53/56] fixes after review --- node/nodeHelper_test.go | 6 +++--- .../consensus/{ => factoryMocks}/consensusComponentsMock.go | 2 +- 2 files changed, 4 insertions(+), 4 deletions(-) rename testscommon/consensus/{ => factoryMocks}/consensusComponentsMock.go (98%) diff --git a/node/nodeHelper_test.go b/node/nodeHelper_test.go index 0ed15ab2a1a..74c792cca52 100644 --- a/node/nodeHelper_test.go +++ b/node/nodeHelper_test.go @@ -7,7 +7,7 @@ import ( "github.com/multiversx/mx-chain-go/errors" "github.com/multiversx/mx-chain-go/factory/mock" "github.com/multiversx/mx-chain-go/node" - "github.com/multiversx/mx-chain-go/testscommon/consensus" + "github.com/multiversx/mx-chain-go/testscommon/consensus/factoryMocks" "github.com/multiversx/mx-chain-go/testscommon/factory" "github.com/multiversx/mx-chain-go/testscommon/mainFactoryMocks" "github.com/stretchr/testify/require" @@ -31,7 +31,7 @@ func TestCreateNode(t *testing.T) { getDefaultStateComponents(), &mainFactoryMocks.StatusComponentsStub{}, &mock.HeartbeatV2ComponentsStub{}, - &consensus.ConsensusComponentsStub{ + &factoryMocks.ConsensusComponentsStub{ GroupSize: 1, }, 0, @@ -57,7 +57,7 @@ func TestCreateNode(t *testing.T) { getDefaultStateComponents(), &mainFactoryMocks.StatusComponentsStub{}, &mock.HeartbeatV2ComponentsStub{}, - &consensus.ConsensusComponentsStub{ + &factoryMocks.ConsensusComponentsStub{ GroupSize: 1, }, 0, diff --git a/testscommon/consensus/consensusComponentsMock.go b/testscommon/consensus/factoryMocks/consensusComponentsMock.go similarity index 98% rename from testscommon/consensus/consensusComponentsMock.go rename to testscommon/consensus/factoryMocks/consensusComponentsMock.go index 376b29121b4..15ca10f356a 100644 --- a/testscommon/consensus/consensusComponentsMock.go +++ b/testscommon/consensus/factoryMocks/consensusComponentsMock.go @@ -1,4 +1,4 @@ -package consensus +package factoryMocks import ( "github.com/multiversx/mx-chain-go/consensus" From 53cf87510ba18f37c79f877cb1bfbb2d507128cd Mon Sep 17 00:00:00 2001 From: axenteoctavian Date: Tue, 23 Jan 2024 12:39:10 +0200 Subject: [PATCH 54/56] fixes after review --- scripts/testnet/deployFullStackSovereignChainWithScreen.sh | 1 + scripts/testnet/variables.sh | 2 +- 2 files changed, 2 insertions(+), 1 deletion(-) diff --git a/scripts/testnet/deployFullStackSovereignChainWithScreen.sh b/scripts/testnet/deployFullStackSovereignChainWithScreen.sh index 5fa7e72820b..916d7ceaffd 100644 --- a/scripts/testnet/deployFullStackSovereignChainWithScreen.sh +++ b/scripts/testnet/deployFullStackSovereignChainWithScreen.sh @@ -14,6 +14,7 @@ sed -i 's/export USE_TXGEN=[01]/export USE_TXGEN=1/' variables.sh sed -i 's/export USE_PROXY=[01]/export USE_PROXY=1/' variables.sh sed -i 's/export USE_ELASTICSEARCH=[01]/export USE_ELASTICSEARCH=1/' variables.sh sed -i 's/export SOVEREIGN_DEPLOY=[01]/export SOVEREIGN_DEPLOY=1/' variables.sh +sed -i 's/export SHARD_VALIDATORCOUNT=[0-2]/export SHARD_VALIDATORCOUNT=3/' variables.sh echo -e "${GREEN}Generating the configuration files...${NC}" ./config.sh diff --git a/scripts/testnet/variables.sh b/scripts/testnet/variables.sh index 8195e633dc0..984e3cfc87d 100644 --- a/scripts/testnet/variables.sh +++ b/scripts/testnet/variables.sh @@ -67,7 +67,7 @@ export SOVEREIGN_DEPLOY=1 # Shard structure export SHARDCOUNT=1 -export SHARD_VALIDATORCOUNT=3 +export SHARD_VALIDATORCOUNT=2 export SHARD_OBSERVERCOUNT=1 export SHARD_CONSENSUS_SIZE=2 From e9532c1aa240e5ff5179c27a1121aa61dc9af9f6 Mon Sep 17 00:00:00 2001 From: axenteoctavian Date: Tue, 23 Jan 2024 13:10:41 +0200 Subject: [PATCH 55/56] fixes after review --- scripts/testnet/deployFullStackSovereignChainWithScreen.sh | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/scripts/testnet/deployFullStackSovereignChainWithScreen.sh b/scripts/testnet/deployFullStackSovereignChainWithScreen.sh index 916d7ceaffd..c9026c06201 100644 --- a/scripts/testnet/deployFullStackSovereignChainWithScreen.sh +++ b/scripts/testnet/deployFullStackSovereignChainWithScreen.sh @@ -14,7 +14,11 @@ sed -i 's/export USE_TXGEN=[01]/export USE_TXGEN=1/' variables.sh sed -i 's/export USE_PROXY=[01]/export USE_PROXY=1/' variables.sh sed -i 's/export USE_ELASTICSEARCH=[01]/export USE_ELASTICSEARCH=1/' variables.sh sed -i 's/export SOVEREIGN_DEPLOY=[01]/export SOVEREIGN_DEPLOY=1/' variables.sh -sed -i 's/export SHARD_VALIDATORCOUNT=[0-2]/export SHARD_VALIDATORCOUNT=3/' variables.sh + +source variables.sh +if [ "$SHARD_VALIDATORCOUNT" -lt 3 ]; then + sed -i 's/export SHARD_VALIDATORCOUNT=.*/export SHARD_VALIDATORCOUNT=3/' variables.sh +fi echo -e "${GREEN}Generating the configuration files...${NC}" ./config.sh From 9b573acd167371a62ae79feb3634e03746c3df63 Mon Sep 17 00:00:00 2001 From: Octavian Axente <45915201+axenteoctavian@users.noreply.github.com> Date: Tue, 23 Jan 2024 15:54:29 +0200 Subject: [PATCH 56/56] Update config.sh --- scripts/testnet/include/config.sh | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/scripts/testnet/include/config.sh b/scripts/testnet/include/config.sh index 02ab854b69a..33c1c6cbe7e 100644 --- a/scripts/testnet/include/config.sh +++ b/scripts/testnet/include/config.sh @@ -8,9 +8,9 @@ generateConfig() { TMP_META_OBSERVERCOUNT=0 fi - SOVEREIGN_DEPLOY=0 - if [ $USE_HARDFORK -eq 1 ]; then - SOVEREIGN_DEPLOY=1 + SOVEREIGN_BOOL="false" + if [ $SOVEREIGN_DEPLOY -eq 1 ]; then + SOVEREIGN_BOOL="true" fi pushd $TESTNETDIR/filegen @@ -25,7 +25,7 @@ generateConfig() { -metachain-consensus-group-size $META_CONSENSUS_SIZE \ -stake-type $GENESIS_STAKE_TYPE \ -hysteresis $HYSTERESIS \ - -sovereign=$SOVEREIGN_DEPLOY + -sovereign=$SOVEREIGN_BOOL popd }