Compute shard id start in epoch false

epochStart/bootstrap/fromLocalStorage.go

@@ -34,7 +34,7 @@ func (e *epochStartBootstrap) initializeFromLocalStorage() {
 	}
 }
 
-func (e *epochStartBootstrap) prepareEpochFromStorage() (Parameters, error) {
+func (e *epochStartBootstrap) getShardIDForLatestEpoch() (uint32, bool, error) {
 	storer, err := e.storageOpenerHandler.GetMostRecentBootstrapStorageUnit()
 	defer func() {
 		if check.IfNil(storer) {
@@ -46,26 +46,35 @@ func (e *epochStartBootstrap) prepareEpochFromStorage() (Parameters, error) {
 	}()
 
 	if err != nil {
-		return Parameters{}, err
+		return 0, false, err
 	}
 
 	_, e.nodesConfig, err = e.getLastBootstrapData(storer)
 	if err != nil {
-		return Parameters{}, err
+		return 0, false, err
 	}
 
 	pubKey, err := e.publicKey.ToByteArray()
 	if err != nil {
-		return Parameters{}, err
+		return 0, false, err
 	}
 
 	e.epochStartMeta, err = e.getEpochStartMetaFromStorage(storer)
 	if err != nil {
-		return Parameters{}, err
+		return 0, false, err
 	}
 	e.baseData.numberOfShards = uint32(len(e.epochStartMeta.EpochStart.LastFinalizedHeaders))
 
 	newShardId, isShuffledOut := e.checkIfShuffledOut(pubKey, e.nodesConfig)
+	return newShardId, isShuffledOut, nil
+}
+
+func (e *epochStartBootstrap) prepareEpochFromStorage() (Parameters, error) {
+	newShardId, isShuffledOut, err := e.getShardIDForLatestEpoch()
+	if err != nil {
+		return Parameters{}, err
+	}
+
 	err = e.createTriesComponentsForShardId(newShardId)
 	if err != nil {
 		return Parameters{}, err

epochStart/bootstrap/process.go

@@ -263,16 +263,33 @@ func (e *epochStartBootstrap) Bootstrap() (Parameters, error) {
 		log.Warn("fast bootstrap is disabled")
 
 		e.initializeFromLocalStorage()
+		if !e.baseData.storageExists {
+			return Parameters{
+				Epoch:       0,
+				SelfShardId: e.genesisShardCoordinator.SelfId(),
+				NumOfShards: e.genesisShardCoordinator.NumberOfShards(),
+			}, nil
+		}
 
-		err := e.createTriesComponentsForShardId(e.genesisShardCoordinator.SelfId())
+		newShardId, shuffledOut, err := e.getShardIDForLatestEpoch()
 		if err != nil {
 			return Parameters{}, err
 		}
 
+		err = e.createTriesComponentsForShardId(newShardId)
+		if err != nil {
+			return Parameters{}, err
+		}
+
+		epochToStart := e.baseData.lastEpoch
+		if shuffledOut {
+			epochToStart = 0
+		}
+
 		return Parameters{
-			Epoch:       e.baseData.lastEpoch,
-			SelfShardId: e.genesisShardCoordinator.SelfId(),
-			NumOfShards: e.genesisShardCoordinator.NumberOfShards(),
+			Epoch:       epochToStart,
+			SelfShardId: newShardId,
+			NumOfShards: e.baseData.numberOfShards,
 		}, nil
 	}
 

epochStart/bootstrap/process_test.go

@@ -2,6 +2,7 @@ package bootstrap
 
 import (
 	"context"
+	"errors"
 	"testing"
 	"time"
 
@@ -161,6 +162,12 @@ func TestIsStartInEpochZero(t *testing.T) {
 func TestEpochStartBootstrap_BootstrapStartInEpochNotEnabled(t *testing.T) {
 	args := createMockEpochStartBootstrapArgs()
 
+	err := errors.New("localErr")
+	args.LatestStorageDataProvider = &mock.LatestStorageDataProviderStub{
+		GetCalled: func() (storage.LatestDataFromStorage, error) {
+			return storage.LatestDataFromStorage{}, err
+		},
+	}
 	epochStartProvider, _ := NewEpochStartBootstrap(args)
 
 	params, err := epochStartProvider.Bootstrap()