Bug fixes staking v4

cmd/node/config/gasSchedules/gasScheduleV1.toml

@@ -39,7 +39,7 @@
     ValidatorToDelegation = 500000000
     GetAllNodeStates      = 100000000
     FixWaitingListSize    = 500000000
-LiquidStakingOps      = 10000000
+    LiquidStakingOps      = 10000000
 
 [BaseOperationCost]
     StorePerByte      = 50000

cmd/node/config/gasSchedules/gasScheduleV4.toml

@@ -39,6 +39,7 @@
     UnstakeTokens         = 5000000
     UnbondTokens          = 5000000
     FixWaitingListSize    = 500000000
+    LiquidStakingOps      = 10000000
 
 [BaseOperationCost]
     StorePerByte      = 10000

cmd/node/config/gasSchedules/gasScheduleV5.toml

@@ -39,6 +39,7 @@
     UnstakeTokens         = 5000000
     UnbondTokens          = 5000000
     FixWaitingListSize    = 500000000
+    LiquidStakingOps      = 10000000
 
 [BaseOperationCost]
     StorePerByte      = 10000

cmd/node/config/gasSchedules/gasScheduleV6.toml

@@ -39,6 +39,7 @@
     UnstakeTokens         = 5000000
     UnbondTokens          = 5000000
     FixWaitingListSize    = 500000000
+    LiquidStakingOps      = 10000000
 
 [BaseOperationCost]
     StorePerByte      = 10000

epochStart/bootstrap/baseStorageHandler.go

@@ -1,29 +1,67 @@
 package bootstrap
 
 import (
-	"encoding/json"
-
 	"github.com/ElrondNetwork/elrond-go-core/core"
+	"github.com/ElrondNetwork/elrond-go-core/core/check"
 	"github.com/ElrondNetwork/elrond-go-core/data"
 	"github.com/ElrondNetwork/elrond-go-core/data/block"
 	"github.com/ElrondNetwork/elrond-go-core/data/typeConverters"
 	"github.com/ElrondNetwork/elrond-go-core/hashing"
 	"github.com/ElrondNetwork/elrond-go-core/marshal"
 	"github.com/ElrondNetwork/elrond-go/common"
+	"github.com/ElrondNetwork/elrond-go/config"
 	"github.com/ElrondNetwork/elrond-go/dataRetriever"
 	"github.com/ElrondNetwork/elrond-go/process/block/bootstrapStorage"
 	"github.com/ElrondNetwork/elrond-go/sharding"
 	"github.com/ElrondNetwork/elrond-go/sharding/nodesCoordinator"
+	"github.com/ElrondNetwork/elrond-go/storage"
 )
 
+// StorageHandlerArgs is a struct placeholder for all arguments required to create either a shard or a meta storage handler
+type StorageHandlerArgs struct {
+	GeneralConfig                   config.Config
+	PreferencesConfig               config.PreferencesConfig
+	ShardCoordinator                sharding.Coordinator
+	PathManagerHandler              storage.PathManagerHandler
+	Marshaller                      marshal.Marshalizer
+	Hasher                          hashing.Hasher
+	CurrentEpoch                    uint32
+	Uint64Converter                 typeConverters.Uint64ByteSliceConverter
+	NodeTypeProvider                NodeTypeProviderHandler
+	NodesCoordinatorRegistryFactory nodesCoordinator.NodesCoordinatorRegistryFactory
+}
+
+func checkNilArgs(args StorageHandlerArgs) error {
+	if check.IfNil(args.ShardCoordinator) {
+		return core.ErrNilShardCoordinator
+	}
+	if check.IfNil(args.PathManagerHandler) {
+		return dataRetriever.ErrNilPathManager
+	}
+	if check.IfNil(args.Marshaller) {
+		return core.ErrNilMarshalizer
+	}
+	if check.IfNil(args.Hasher) {
+		return core.ErrNilHasher
+	}
+	if check.IfNil(args.Uint64Converter) {
+		return dataRetriever.ErrNilUint64ByteSliceConverter
+	}
+	if check.IfNil(args.NodesCoordinatorRegistryFactory) {
+		return nodesCoordinator.ErrNilNodesCoordinatorRegistryFactory
+	}
+	return nil
+}
+
 // baseStorageHandler handles the storage functions for saving bootstrap data
 type baseStorageHandler struct {
-	storageService   dataRetriever.StorageService
-	shardCoordinator sharding.Coordinator
-	marshalizer      marshal.Marshalizer
-	hasher           hashing.Hasher
-	currentEpoch     uint32
-	uint64Converter  typeConverters.Uint64ByteSliceConverter
+	storageService                  dataRetriever.StorageService
+	shardCoordinator                sharding.Coordinator
+	marshalizer                     marshal.Marshalizer
+	hasher                          hashing.Hasher
+	currentEpoch                    uint32
+	uint64Converter                 typeConverters.Uint64ByteSliceConverter
+	nodesCoordinatorRegistryFactory nodesCoordinator.NodesCoordinatorRegistryFactory
 }
 
 func (bsh *baseStorageHandler) groupMiniBlocksByShard(miniBlocks map[string]*block.MiniBlock) ([]bootstrapStorage.PendingMiniBlocksInfo, error) {
@@ -50,8 +88,7 @@ func (bsh *baseStorageHandler) saveNodesCoordinatorRegistry(
 ) ([]byte, error) {
 	key := append([]byte(common.NodesCoordinatorRegistryKeyPrefix), metaBlock.GetPrevRandSeed()...)
 
-	// TODO: replace hardcoded json - although it is hardcoded in nodesCoordinator as well.
-	registryBytes, err := json.Marshal(nodesConfig)
+	registryBytes, err := bsh.nodesCoordinatorRegistryFactory.GetRegistryData(nodesConfig, metaBlock.GetEpoch())
 	if err != nil {
 		return nil, err
 	}

epochStart/bootstrap/interface.go

@@ -25,7 +25,7 @@ type EpochStartMetaBlockInterceptorProcessor interface {
 // StartInEpochNodesCoordinator defines the methods to process and save nodesCoordinator information to storage
 type StartInEpochNodesCoordinator interface {
 	EpochStartPrepare(metaHdr data.HeaderHandler, body data.BodyHandler)
-	NodesCoordinatorToRegistry() nodesCoordinator.NodesCoordinatorRegistryHandler
+	NodesCoordinatorToRegistry(epoch uint32) nodesCoordinator.NodesCoordinatorRegistryHandler
 	ShardIdForEpoch(epoch uint32) (uint32, error)
 	IsInterfaceNil() bool
 }

epochStart/bootstrap/metaStorageHandler.go

@@ -7,17 +7,11 @@ import (
 	"github.com/ElrondNetwork/elrond-go-core/core"
 	"github.com/ElrondNetwork/elrond-go-core/data"
 	"github.com/ElrondNetwork/elrond-go-core/data/block"
-	"github.com/ElrondNetwork/elrond-go-core/data/typeConverters"
-	"github.com/ElrondNetwork/elrond-go-core/hashing"
-	"github.com/ElrondNetwork/elrond-go-core/marshal"
 	"github.com/ElrondNetwork/elrond-go/common"
-	"github.com/ElrondNetwork/elrond-go/config"
 	"github.com/ElrondNetwork/elrond-go/dataRetriever"
 	"github.com/ElrondNetwork/elrond-go/epochStart"
 	"github.com/ElrondNetwork/elrond-go/epochStart/bootstrap/disabled"
 	"github.com/ElrondNetwork/elrond-go/process/block/bootstrapStorage"
-	"github.com/ElrondNetwork/elrond-go/sharding"
-	"github.com/ElrondNetwork/elrond-go/storage"
 	"github.com/ElrondNetwork/elrond-go/storage/factory"
 )
 
@@ -26,26 +20,21 @@ type metaStorageHandler struct {
 }
 
 // NewMetaStorageHandler will return a new instance of metaStorageHandler
-func NewMetaStorageHandler(
-	generalConfig config.Config,
-	prefsConfig config.PreferencesConfig,
-	shardCoordinator sharding.Coordinator,
-	pathManagerHandler storage.PathManagerHandler,
-	marshalizer marshal.Marshalizer,
-	hasher hashing.Hasher,
-	currentEpoch uint32,
-	uint64Converter typeConverters.Uint64ByteSliceConverter,
-	nodeTypeProvider NodeTypeProviderHandler,
-) (*metaStorageHandler, error) {
+func NewMetaStorageHandler(args StorageHandlerArgs) (*metaStorageHandler, error) {
+	err := checkNilArgs(args)
+	if err != nil {
+		return nil, err
+	}
+
 	epochStartNotifier := &disabled.EpochStartNotifier{}
 	storageFactory, err := factory.NewStorageServiceFactory(
-		&generalConfig,
-		&prefsConfig,
-		shardCoordinator,
-		pathManagerHandler,
+		&args.GeneralConfig,
+		&args.PreferencesConfig,
+		args.ShardCoordinator,
+		args.PathManagerHandler,
 		epochStartNotifier,
-		nodeTypeProvider,
-		currentEpoch,
+		args.NodeTypeProvider,
+		args.CurrentEpoch,
 		false,
 	)
 	if err != nil {
@@ -58,12 +47,13 @@ func NewMetaStorageHandler(
 	}
 
 	base := &baseStorageHandler{
-		storageService:   storageService,
-		shardCoordinator: shardCoordinator,
-		marshalizer:      marshalizer,
-		hasher:           hasher,
-		currentEpoch:     currentEpoch,
-		uint64Converter:  uint64Converter,
+		storageService:                  storageService,
+		shardCoordinator:                args.ShardCoordinator,
+		marshalizer:                     args.Marshaller,
+		hasher:                          args.Hasher,
+		currentEpoch:                    args.CurrentEpoch,
+		uint64Converter:                 args.Uint64Converter,
+		nodesCoordinatorRegistryFactory: args.NodesCoordinatorRegistryFactory,
 	}
 
 	return &metaStorageHandler{baseStorageHandler: base}, nil

epochStart/bootstrap/metaStorageHandler_test.go

@@ -14,20 +14,30 @@ import (
 	"github.com/ElrondNetwork/elrond-go/testscommon"
 	"github.com/ElrondNetwork/elrond-go/testscommon/hashingMocks"
 	"github.com/ElrondNetwork/elrond-go/testscommon/nodeTypeProviderMock"
+	"github.com/ElrondNetwork/elrond-go/testscommon/shardingMocks"
 	"github.com/stretchr/testify/assert"
 )
 
+func createStorageHandlerArgs() StorageHandlerArgs {
+	return StorageHandlerArgs{
+		GeneralConfig:                   testscommon.GetGeneralConfig(),
+		PreferencesConfig:               config.PreferencesConfig{},
+		ShardCoordinator:                &mock.ShardCoordinatorStub{},
+		PathManagerHandler:              &testscommon.PathManagerStub{},
+		Marshaller:                      &mock.MarshalizerMock{},
+		Hasher:                          &hashingMocks.HasherMock{},
+		CurrentEpoch:                    0,
+		Uint64Converter:                 &mock.Uint64ByteSliceConverterMock{},
+		NodeTypeProvider:                &nodeTypeProviderMock.NodeTypeProviderStub{},
+		NodesCoordinatorRegistryFactory: &shardingMocks.NodesCoordinatorRegistryFactoryMock{},
+	}
+}
+
 func TestNewMetaStorageHandler_InvalidConfigErr(t *testing.T) {
-	gCfg := config.Config{}
-	prefsConfig := config.PreferencesConfig{}
-	coordinator := &mock.ShardCoordinatorStub{}
-	pathManager := &testscommon.PathManagerStub{}
-	marshalizer := &mock.MarshalizerMock{}
-	hasher := &hashingMocks.HasherMock{}
-	uit64Cvt := &mock.Uint64ByteSliceConverterMock{}
-	nodeTypeProvider := &nodeTypeProviderMock.NodeTypeProviderStub{}
-
-	mtStrHandler, err := NewMetaStorageHandler(gCfg, prefsConfig, coordinator, pathManager, marshalizer, hasher, 1, uit64Cvt, nodeTypeProvider)
+	args := createStorageHandlerArgs()
+	args.GeneralConfig = config.Config{}
+
+	mtStrHandler, err := NewMetaStorageHandler(args)
 	assert.True(t, check.IfNil(mtStrHandler))
 	assert.NotNil(t, err)
 }
@@ -37,16 +47,8 @@ func TestNewMetaStorageHandler_CreateForMetaErr(t *testing.T) {
 		_ = os.RemoveAll("./Epoch_0")
 	}()
 
-	gCfg := testscommon.GetGeneralConfig()
-	prefsConfig := config.PreferencesConfig{}
-	coordinator := &mock.ShardCoordinatorStub{}
-	pathManager := &testscommon.PathManagerStub{}
-	marshalizer := &mock.MarshalizerMock{}
-	hasher := &hashingMocks.HasherMock{}
-	uit64Cvt := &mock.Uint64ByteSliceConverterMock{}
-	nodeTypeProvider := &nodeTypeProviderMock.NodeTypeProviderStub{}
-
-	mtStrHandler, err := NewMetaStorageHandler(gCfg, prefsConfig, coordinator, pathManager, marshalizer, hasher, 1, uit64Cvt, nodeTypeProvider)
+	args := createStorageHandlerArgs()
+	mtStrHandler, err := NewMetaStorageHandler(args)
 	assert.False(t, check.IfNil(mtStrHandler))
 	assert.Nil(t, err)
 }
@@ -56,20 +58,11 @@ func TestMetaStorageHandler_saveLastHeader(t *testing.T) {
 		_ = os.RemoveAll("./Epoch_0")
 	}()
 
-	gCfg := testscommon.GetGeneralConfig()
-	prefsConfig := config.PreferencesConfig{}
-	coordinator := &mock.ShardCoordinatorStub{}
-	pathManager := &testscommon.PathManagerStub{}
-	marshalizer := &mock.MarshalizerMock{}
-	hasher := &hashingMocks.HasherMock{}
-	uit64Cvt := &mock.Uint64ByteSliceConverterMock{}
-	nodeTypeProvider := &nodeTypeProviderMock.NodeTypeProviderStub{}
-
-	mtStrHandler, _ := NewMetaStorageHandler(gCfg, prefsConfig, coordinator, pathManager, marshalizer, hasher, 1, uit64Cvt, nodeTypeProvider)
-
+	args := createStorageHandlerArgs()
+	mtStrHandler, _ := NewMetaStorageHandler(args)
 	header := &block.MetaBlock{Nonce: 0}
 
-	headerHash, _ := core.CalculateHash(marshalizer, hasher, header)
+	headerHash, _ := core.CalculateHash(args.Marshaller, args.Hasher, header)
 	expectedBootInfo := bootstrapStorage.BootstrapHeaderInfo{
 		ShardId: core.MetachainShardId, Hash: headerHash,
 	}
@@ -84,21 +77,13 @@ func TestMetaStorageHandler_saveLastCrossNotarizedHeaders(t *testing.T) {
 		_ = os.RemoveAll("./Epoch_0")
 	}()
 
-	gCfg := testscommon.GetGeneralConfig()
-	prefsConfig := config.PreferencesConfig{}
-	coordinator := &mock.ShardCoordinatorStub{}
-	pathManager := &testscommon.PathManagerStub{}
-	marshalizer := &mock.MarshalizerMock{}
-	hasher := &hashingMocks.HasherMock{}
-	uit64Cvt := &mock.Uint64ByteSliceConverterMock{}
-	nodeTypeProvider := &nodeTypeProviderMock.NodeTypeProviderStub{}
-
-	mtStrHandler, _ := NewMetaStorageHandler(gCfg, prefsConfig, coordinator, pathManager, marshalizer, hasher, 1, uit64Cvt, nodeTypeProvider)
+	args := createStorageHandlerArgs()
+	mtStrHandler, _ := NewMetaStorageHandler(args)
 
 	hdr1 := &block.Header{Nonce: 1}
 	hdr2 := &block.Header{Nonce: 2}
-	hdrHash1, _ := core.CalculateHash(marshalizer, hasher, hdr1)
-	hdrHash2, _ := core.CalculateHash(marshalizer, hasher, hdr2)
+	hdrHash1, _ := core.CalculateHash(args.Marshaller, args.Hasher, hdr1)
+	hdrHash2, _ := core.CalculateHash(args.Marshaller, args.Hasher, hdr2)
 
 	hdr3 := &block.MetaBlock{
 		Nonce: 3,
@@ -118,16 +103,8 @@ func TestMetaStorageHandler_saveTriggerRegistry(t *testing.T) {
 		_ = os.RemoveAll("./Epoch_0")
 	}()
 
-	gCfg := testscommon.GetGeneralConfig()
-	prefsConfig := config.PreferencesConfig{}
-	coordinator := &mock.ShardCoordinatorStub{}
-	pathManager := &testscommon.PathManagerStub{}
-	marshalizer := &mock.MarshalizerMock{}
-	hasher := &hashingMocks.HasherMock{}
-	uit64Cvt := &mock.Uint64ByteSliceConverterMock{}
-	nodeTypeProvider := &nodeTypeProviderMock.NodeTypeProviderStub{}
-
-	mtStrHandler, _ := NewMetaStorageHandler(gCfg, prefsConfig, coordinator, pathManager, marshalizer, hasher, 1, uit64Cvt, nodeTypeProvider)
+	args := createStorageHandlerArgs()
+	mtStrHandler, _ := NewMetaStorageHandler(args)
 
 	components := &ComponentsNeededForBootstrap{
 		EpochStartMetaBlock: &block.MetaBlock{Nonce: 3},
@@ -143,16 +120,8 @@ func TestMetaStorageHandler_saveDataToStorage(t *testing.T) {
 		_ = os.RemoveAll("./Epoch_0")
 	}()
 
-	gCfg := testscommon.GetGeneralConfig()
-	prefsConfig := config.PreferencesConfig{}
-	coordinator := &mock.ShardCoordinatorStub{}
-	pathManager := &testscommon.PathManagerStub{}
-	marshalizer := &mock.MarshalizerMock{}
-	hasher := &hashingMocks.HasherMock{}
-	uit64Cvt := &mock.Uint64ByteSliceConverterMock{}
-	nodeTypeProvider := &nodeTypeProviderMock.NodeTypeProviderStub{}
-
-	mtStrHandler, _ := NewMetaStorageHandler(gCfg, prefsConfig, coordinator, pathManager, marshalizer, hasher, 1, uit64Cvt, nodeTypeProvider)
+	args := createStorageHandlerArgs()
+	mtStrHandler, _ := NewMetaStorageHandler(args)
 
 	components := &ComponentsNeededForBootstrap{
 		EpochStartMetaBlock: &block.MetaBlock{Nonce: 3},