diff --git a/cmd/sovereignnode/go.mod b/cmd/sovereignnode/go.mod index 80437198112..04bed81c922 100644 --- a/cmd/sovereignnode/go.mod +++ b/cmd/sovereignnode/go.mod @@ -6,7 +6,7 @@ go 1.20 require ( github.com/google/gops v0.3.18 - github.com/multiversx/mx-chain-core-go v1.2.25-0.20250131122047-725dd68e256f + github.com/multiversx/mx-chain-core-go v1.2.25-0.20250206111825-25fbb1b4851c github.com/multiversx/mx-chain-go v1.8.4 github.com/multiversx/mx-chain-logger-go v1.0.15 github.com/multiversx/mx-chain-sovereign-bridge-go v0.0.0-20240116102202-4cf6fbbd95a3 diff --git a/cmd/sovereignnode/go.sum b/cmd/sovereignnode/go.sum index c8e997ae856..b87cd5de40b 100644 --- a/cmd/sovereignnode/go.sum +++ b/cmd/sovereignnode/go.sum @@ -385,8 +385,8 @@ github.com/multiversx/concurrent-map v0.1.4 h1:hdnbM8VE4b0KYJaGY5yJS2aNIW9TFFsUY github.com/multiversx/concurrent-map v0.1.4/go.mod h1:8cWFRJDOrWHOTNSqgYCUvwT7c7eFQ4U2vKMOp4A/9+o= github.com/multiversx/mx-chain-communication-go v1.1.1 h1:y4DoQeQOJTaSUsRzczQFazf8JYQmInddypApqA3AkwM= github.com/multiversx/mx-chain-communication-go v1.1.1/go.mod h1:WK6bP4pGEHGDDna/AYRIMtl6G9OA0NByI1Lw8PmOnRM= -github.com/multiversx/mx-chain-core-go v1.2.25-0.20250131122047-725dd68e256f h1:iyDk0Zk0n4pHZnrdX30SxevTy+xg9GcEyAmBss45Nfs= -github.com/multiversx/mx-chain-core-go v1.2.25-0.20250131122047-725dd68e256f/go.mod h1:P/YBoFnt25XUaCQ7Q/SD15vhnc9yV5JDhHxyFO9P8Z0= +github.com/multiversx/mx-chain-core-go v1.2.25-0.20250206111825-25fbb1b4851c h1:Cz5b0xd9lbSWGIwmfuPuHqL0e5kTun/PW5NpkVRIAXQ= +github.com/multiversx/mx-chain-core-go v1.2.25-0.20250206111825-25fbb1b4851c/go.mod h1:P/YBoFnt25XUaCQ7Q/SD15vhnc9yV5JDhHxyFO9P8Z0= github.com/multiversx/mx-chain-crypto-go v1.2.12 h1:zWip7rpUS4CGthJxfKn5MZfMfYPjVjIiCID6uX5BSOk= github.com/multiversx/mx-chain-crypto-go v1.2.12/go.mod h1:HzcPpCm1zanNct/6h2rIh+MFrlXbjA5C8+uMyXj3LI4= github.com/multiversx/mx-chain-es-indexer-go v1.7.15-0.20250131125841-73868f5ca49c h1:Qm84hhybDLTeS+BLebFYgmGJpkX+AUnzZsUC+u9KzBU= diff --git a/epochStart/bootstrap/sovereignEpochStartBootstrapperFactory.go b/epochStart/bootstrap/sovereignEpochStartBootstrapperFactory.go index 6246d42e6eb..3b9c29a2ff2 100644 --- a/epochStart/bootstrap/sovereignEpochStartBootstrapperFactory.go +++ b/epochStart/bootstrap/sovereignEpochStartBootstrapperFactory.go @@ -1,23 +1,12 @@ package bootstrap -import ( - "github.com/multiversx/mx-chain-core-go/core/check" - "github.com/multiversx/mx-chain-go/errors" -) - // sovereignEpochStartBootstrapperFactory defines the epoch start bootstrapper factory for chain run sovereign type sovereignEpochStartBootstrapperFactory struct { - epochStartBootstrapperFactory EpochStartBootstrapperCreator } // NewSovereignEpochStartBootstrapperFactory creates a new epoch start bootstrapper factory for chain run sovereign -func NewSovereignEpochStartBootstrapperFactory(esbf EpochStartBootstrapperCreator) (EpochStartBootstrapperCreator, error) { - if check.IfNil(esbf) { - return nil, errors.ErrNilEpochStartBootstrapperFactory - } - return &sovereignEpochStartBootstrapperFactory{ - epochStartBootstrapperFactory: esbf, - }, nil +func NewSovereignEpochStartBootstrapperFactory() EpochStartBootstrapperCreator { + return &sovereignEpochStartBootstrapperFactory{} } // CreateEpochStartBootstrapper creates a new epoch start bootstrapper for sovereign chain operations diff --git a/epochStart/bootstrap/sovereignEpochStartBootstrapperFactory_test.go b/epochStart/bootstrap/sovereignEpochStartBootstrapperFactory_test.go index b6abd0fd0a4..ae55e3f4ba6 100644 --- a/epochStart/bootstrap/sovereignEpochStartBootstrapperFactory_test.go +++ b/epochStart/bootstrap/sovereignEpochStartBootstrapperFactory_test.go @@ -1,48 +1,35 @@ package bootstrap import ( + "fmt" "testing" - "github.com/multiversx/mx-chain-go/config" - "github.com/multiversx/mx-chain-go/errors" - "github.com/multiversx/mx-chain-core-go/data/endProcess" "github.com/stretchr/testify/require" + + "github.com/multiversx/mx-chain-go/config" ) func TestNewSovereignEpochStartBootstrapperFactory(t *testing.T) { t.Parallel() - sebf, err := NewSovereignEpochStartBootstrapperFactory(nil) - - require.Nil(t, sebf) - require.Equal(t, errors.ErrNilEpochStartBootstrapperFactory, err) - - esbf := NewEpochStartBootstrapperFactory() - sebf, err = NewSovereignEpochStartBootstrapperFactory(esbf) - - require.Nil(t, err) - require.NotNil(t, sebf) + sebf := NewSovereignEpochStartBootstrapperFactory() + require.False(t, sebf.IsInterfaceNil()) } func TestSovereignEpochStartBootstrapperFactory_CreateEpochStartBootstrapper(t *testing.T) { t.Parallel() - esbf := NewEpochStartBootstrapperFactory() - sebf, _ := NewSovereignEpochStartBootstrapperFactory(esbf) - + sebf := NewSovereignEpochStartBootstrapperFactory() seb, err := sebf.CreateEpochStartBootstrapper(getDefaultArgs()) - require.Nil(t, err) - require.NotNil(t, seb) + require.Equal(t, "*bootstrap.sovereignChainEpochStartBootstrap", fmt.Sprintf("%T", seb)) } func TestSovereignEpochStartBootstrapperFactory_CreateStorageEpochStartBootstrapper(t *testing.T) { t.Parallel() - esbf := NewEpochStartBootstrapperFactory() - sebf, _ := NewSovereignEpochStartBootstrapperFactory(esbf) - + sebf := NewSovereignEpochStartBootstrapperFactory() arg := ArgsStorageEpochStartBootstrap{ ArgsEpochStartBootstrap: getDefaultArgs(), ImportDbConfig: config.ImportDbConfig{}, @@ -50,20 +37,7 @@ func TestSovereignEpochStartBootstrapperFactory_CreateStorageEpochStartBootstrap TimeToWaitForRequestedData: 1, } esb, err := sebf.CreateStorageEpochStartBootstrapper(arg) - require.Nil(t, err) - require.NotNil(t, esb) - -} - -func TestSovereignEpochStartBootstrapperFactory_IsInterfaceNil(t *testing.T) { - t.Parallel() - - esbf := NewEpochStartBootstrapperFactory() - sebf, _ := NewSovereignEpochStartBootstrapperFactory(esbf) - - require.False(t, sebf.IsInterfaceNil()) + require.Equal(t, "*bootstrap.storageEpochStartBootstrap", fmt.Sprintf("%T", esb)) - sebf = (*sovereignEpochStartBootstrapperFactory)(nil) - require.True(t, sebf.IsInterfaceNil()) } diff --git a/errors/errors.go b/errors/errors.go index 008d5d5c2fa..0558a66b0a3 100644 --- a/errors/errors.go +++ b/errors/errors.go @@ -874,3 +874,6 @@ var ErrNilAPIRewardsHandler = errors.New("nil api rewards handler has been provi // ErrNilOutportDataProviderFactory signals that a nil outport data provider factory has been provided var ErrNilOutportDataProviderFactory = errors.New("nil outport data provider factory has been provided") + +// ErrReceivedSovereignEpochStartBlockWithExtendedHeaders signals that an invalid epoch start sovereign block has been received +var ErrReceivedSovereignEpochStartBlockWithExtendedHeaders = errors.New("received invalid epoch start sovereign block, should not contain any extended headers") diff --git a/factory/epochStartTrigger/common.go b/factory/epochStartTrigger/common.go new file mode 100644 index 00000000000..a44dfbdedc3 --- /dev/null +++ b/factory/epochStartTrigger/common.go @@ -0,0 +1,38 @@ +package epochStartTrigger + +import ( + "github.com/multiversx/mx-chain-core-go/core/check" + + "github.com/multiversx/mx-chain-go/dataRetriever" + "github.com/multiversx/mx-chain-go/factory" + "github.com/multiversx/mx-chain-go/process" +) + +func checkNilArgs(args factory.ArgsEpochStartTrigger) error { + if check.IfNil(args.DataComps) { + return process.ErrNilDataComponentsHolder + } + if check.IfNil(args.DataComps.Datapool()) { + return process.ErrNilDataPoolHolder + } + if check.IfNil(args.DataComps.Blockchain()) { + return process.ErrNilBlockChain + } + if check.IfNil(args.DataComps.Datapool().MiniBlocks()) { + return dataRetriever.ErrNilMiniblocksPool + } + if check.IfNil(args.DataComps.Datapool().ValidatorsInfo()) { + return process.ErrNilValidatorInfoPool + } + if check.IfNil(args.BootstrapComponents) { + return process.ErrNilBootstrapComponentsHolder + } + if check.IfNil(args.BootstrapComponents.ShardCoordinator()) { + return process.ErrNilShardCoordinator + } + if check.IfNil(args.RequestHandler) { + return process.ErrNilRequestHandler + } + + return nil +} diff --git a/factory/epochStartTrigger/common_test.go b/factory/epochStartTrigger/common_test.go new file mode 100644 index 00000000000..67cee081dc6 --- /dev/null +++ b/factory/epochStartTrigger/common_test.go @@ -0,0 +1,82 @@ +package epochStartTrigger + +import ( + "testing" + + "github.com/stretchr/testify/require" + + "github.com/multiversx/mx-chain-go/dataRetriever" + "github.com/multiversx/mx-chain-go/process" + "github.com/multiversx/mx-chain-go/storage" +) + +func TestCheckNilArgs(t *testing.T) { + t.Parallel() + + t.Run("nil data comps", func(t *testing.T) { + args := createArgs(0) + args.DataComps = nil + err := checkNilArgs(args) + require.Equal(t, process.ErrNilDataComponentsHolder, err) + }) + t.Run("nil data pool", func(t *testing.T) { + args := createArgs(0) + dataComps := createDataCompsMock() + dataComps.DataPool = nil + args.DataComps = dataComps + err := checkNilArgs(args) + require.Equal(t, process.ErrNilDataPoolHolder, err) + }) + t.Run("nil blockchain", func(t *testing.T) { + args := createArgs(0) + dataComps := createDataCompsMock() + dataComps.BlockChain = nil + args.DataComps = dataComps + err := checkNilArgs(args) + require.Equal(t, process.ErrNilBlockChain, err) + }) + t.Run("nil mb pool", func(t *testing.T) { + args := createArgs(0) + dataComps := createDataCompsMock() + dataPool := createDataPoolMock() + dataPool.MiniBlocksCalled = func() storage.Cacher { + return nil + } + dataComps.DataPool = dataPool + args.DataComps = dataComps + err := checkNilArgs(args) + require.Equal(t, dataRetriever.ErrNilMiniblocksPool, err) + }) + t.Run("nil validator pool", func(t *testing.T) { + args := createArgs(0) + dataComps := createDataCompsMock() + dataPool := createDataPoolMock() + dataPool.ValidatorsInfoCalled = func() dataRetriever.ShardedDataCacherNotifier { + return nil + } + dataComps.DataPool = dataPool + args.DataComps = dataComps + err := checkNilArgs(args) + require.Equal(t, process.ErrNilValidatorInfoPool, err) + }) + t.Run("nil bootstrap comps", func(t *testing.T) { + args := createArgs(0) + args.BootstrapComponents = nil + err := checkNilArgs(args) + require.Equal(t, process.ErrNilBootstrapComponentsHolder, err) + }) + t.Run("nil shard coordinator", func(t *testing.T) { + args := createArgs(0) + bootStrapComps := createBootstrapComps(0) + bootStrapComps.ShardCoordinatorCalled = nil + args.BootstrapComponents = bootStrapComps + err := checkNilArgs(args) + require.Equal(t, process.ErrNilShardCoordinator, err) + }) + t.Run("nil request handler", func(t *testing.T) { + args := createArgs(0) + args.RequestHandler = nil + err := checkNilArgs(args) + require.Equal(t, process.ErrNilRequestHandler, err) + }) +} diff --git a/factory/epochStartTrigger/epochStartTriggerFactory.go b/factory/epochStartTrigger/epochStartTriggerFactory.go index e4c94c50608..c343acce180 100644 --- a/factory/epochStartTrigger/epochStartTriggerFactory.go +++ b/factory/epochStartTrigger/epochStartTriggerFactory.go @@ -1,11 +1,12 @@ package epochStartTrigger import ( - "errors" + "fmt" "time" "github.com/multiversx/mx-chain-core-go/core" "github.com/multiversx/mx-chain-core-go/core/check" + "github.com/multiversx/mx-chain-go/epochStart" "github.com/multiversx/mx-chain-go/epochStart/metachain" "github.com/multiversx/mx-chain-go/epochStart/shardchain" @@ -15,8 +16,6 @@ import ( "github.com/multiversx/mx-chain-go/process/block" ) -// TODO: MX-15632 Unit tests + fix import cycle - type epochStartTriggerFactory struct { } @@ -29,6 +28,11 @@ func NewEpochStartTriggerFactory() *epochStartTriggerFactory { // CreateEpochStartTrigger creates an epoch start trigger for normal run type func (f *epochStartTriggerFactory) CreateEpochStartTrigger(args factory.ArgsEpochStartTrigger) (epochStart.TriggerHandler, error) { + err := checkNilArgs(args) + if err != nil { + return nil, err + } + shardCoordinator := args.BootstrapComponents.ShardCoordinator() if shardCoordinator.SelfId() < shardCoordinator.NumberOfShards() { @@ -38,7 +42,7 @@ func (f *epochStartTriggerFactory) CreateEpochStartTrigger(args factory.ArgsEpoc return createMetaEpochStartTrigger(args) } - return nil, errors.New("error creating new start of epoch trigger because of invalid shard id") + return nil, fmt.Errorf("error creating new start of epoch trigger, errror: %w", process.ErrInvalidShardId) } func createShardEpochStartTrigger(args factory.ArgsEpochStartTrigger) (epochStart.TriggerHandler, error) { diff --git a/factory/epochStartTrigger/epochStartTriggerFactory_test.go b/factory/epochStartTrigger/epochStartTriggerFactory_test.go new file mode 100644 index 00000000000..14f34b9c162 --- /dev/null +++ b/factory/epochStartTrigger/epochStartTriggerFactory_test.go @@ -0,0 +1,153 @@ +package epochStartTrigger + +import ( + "fmt" + "testing" + + "github.com/multiversx/mx-chain-core-go/core" + "github.com/multiversx/mx-chain-core-go/data" + "github.com/multiversx/mx-chain-core-go/data/block" + "github.com/multiversx/mx-chain-core-go/data/typeConverters" + "github.com/multiversx/mx-chain-core-go/hashing" + "github.com/multiversx/mx-chain-core-go/marshal" + "github.com/stretchr/testify/require" + + "github.com/multiversx/mx-chain-go/common" + "github.com/multiversx/mx-chain-go/config" + "github.com/multiversx/mx-chain-go/consensus" + retriever "github.com/multiversx/mx-chain-go/dataRetriever" + "github.com/multiversx/mx-chain-go/factory" + nodeFactoryMock "github.com/multiversx/mx-chain-go/node/mock/factory" + "github.com/multiversx/mx-chain-go/process" + "github.com/multiversx/mx-chain-go/process/mock" + "github.com/multiversx/mx-chain-go/sharding" + shardingMock "github.com/multiversx/mx-chain-go/sharding/mock" + chainStorage "github.com/multiversx/mx-chain-go/storage" + "github.com/multiversx/mx-chain-go/testscommon" + "github.com/multiversx/mx-chain-go/testscommon/bootstrapMocks" + "github.com/multiversx/mx-chain-go/testscommon/dataRetriever" + testsFactory "github.com/multiversx/mx-chain-go/testscommon/factory" + "github.com/multiversx/mx-chain-go/testscommon/genesisMocks" + "github.com/multiversx/mx-chain-go/testscommon/mainFactoryMocks" + "github.com/multiversx/mx-chain-go/testscommon/pool" + "github.com/multiversx/mx-chain-go/testscommon/statusHandler" + "github.com/multiversx/mx-chain-go/testscommon/storage" + validatorInfoCacherStub "github.com/multiversx/mx-chain-go/testscommon/validatorInfoCacher" + updateMock "github.com/multiversx/mx-chain-go/update/mock" +) + +func createArgs(shardID uint32) factory.ArgsEpochStartTrigger { + return factory.ArgsEpochStartTrigger{ + RequestHandler: &testscommon.RequestHandlerStub{}, + CoreData: &testsFactory.CoreComponentsHolderMock{ + HasherCalled: func() hashing.Hasher { + return &testscommon.HasherStub{} + }, + InternalMarshalizerCalled: func() marshal.Marshalizer { + return &testscommon.MarshallerStub{} + }, + Uint64ByteSliceConverterCalled: func() typeConverters.Uint64ByteSliceConverter { + return &testscommon.Uint64ByteSliceConverterStub{} + }, + EpochStartNotifierWithConfirmCalled: func() factory.EpochStartNotifierWithConfirm { + return &updateMock.EpochStartNotifierStub{} + }, + RoundHandlerCalled: func() consensus.RoundHandler { + return &testscommon.RoundHandlerMock{} + }, + EnableEpochsHandlerCalled: func() common.EnableEpochsHandler { + return &shardingMock.EnableEpochsHandlerMock{} + }, + GenesisNodesSetupCalled: func() sharding.GenesisNodesSetupHandler { + return &genesisMocks.NodesSetupStub{} + }, + }, + BootstrapComponents: createBootstrapComps(shardID), + DataComps: createDataCompsMock(), + StatusCoreComponentsHolder: &testsFactory.StatusCoreComponentsStub{ + AppStatusHandlerField: &statusHandler.AppStatusHandlerStub{}, + }, + RunTypeComponentsHolder: mainFactoryMocks.NewRunTypeComponentsStub(), + Config: config.Config{ + EpochStartConfig: config.EpochStartConfig{ + RoundsPerEpoch: 22, + MinRoundsBetweenEpochs: 22, + }, + }, + } +} + +func createBootstrapComps(shardID uint32) *mainFactoryMocks.BootstrapComponentsStub { + return &mainFactoryMocks.BootstrapComponentsStub{ + ShardCoordinatorCalled: func() sharding.Coordinator { + return &testscommon.ShardsCoordinatorMock{ + NoShards: 1, + SelfIDCalled: func() uint32 { + return shardID + }, + } + }, + BootstrapParams: &bootstrapMocks.BootstrapParamsHandlerMock{}, + HdrIntegrityVerifier: &mock.HeaderIntegrityVerifierStub{}, + Bootstrapper: &bootstrapMocks.EpochStartBootstrapperStub{}, + } +} + +func createDataCompsMock() *nodeFactoryMock.DataComponentsMock { + return &nodeFactoryMock.DataComponentsMock{ + DataPool: createDataPoolMock(), + Store: &storage.ChainStorerStub{ + GetStorerCalled: func(unitType retriever.UnitType) (chainStorage.Storer, error) { + return &storage.StorerStub{}, nil + }, + }, + BlockChain: &testscommon.ChainHandlerStub{ + GetGenesisHeaderCalled: func() data.HeaderHandler { + return &block.HeaderV2{} + }, + }, + } +} + +func createDataPoolMock() *dataRetriever.PoolsHolderStub { + return &dataRetriever.PoolsHolderStub{ + MetaBlocksCalled: func() chainStorage.Cacher { + return &testscommon.CacherStub{} + }, + HeadersCalled: func() retriever.HeadersPool { + return &pool.HeadersPoolStub{} + }, + ValidatorsInfoCalled: func() retriever.ShardedDataCacherNotifier { + return &testscommon.ShardedDataCacheNotifierMock{} + }, + CurrEpochValidatorInfoCalled: func() retriever.ValidatorInfoCacher { + return &validatorInfoCacherStub.ValidatorInfoCacherStub{} + }, + } +} + +func TestNewEpochStartTriggerFactory(t *testing.T) { + t.Parallel() + + f := NewEpochStartTriggerFactory() + require.False(t, f.IsInterfaceNil()) + + t.Run("create for shard", func(t *testing.T) { + args := createArgs(0) + trigger, err := f.CreateEpochStartTrigger(args) + require.Nil(t, err) + require.Equal(t, "*shardchain.trigger", fmt.Sprintf("%T", trigger)) + }) + t.Run("create for meta", func(t *testing.T) { + args := createArgs(core.MetachainShardId) + trigger, err := f.CreateEpochStartTrigger(args) + require.Nil(t, err) + require.Equal(t, "*metachain.trigger", fmt.Sprintf("%T", trigger)) + }) + t.Run("invalid shard id", func(t *testing.T) { + args := createArgs(444) + trigger, err := f.CreateEpochStartTrigger(args) + require.ErrorIs(t, err, process.ErrInvalidShardId) + require.Nil(t, trigger) + }) +} diff --git a/factory/epochStartTrigger/sovereignEpochStartTriggerFactory.go b/factory/epochStartTrigger/sovereignEpochStartTriggerFactory.go index c4305c23c75..2d4b5ffe804 100644 --- a/factory/epochStartTrigger/sovereignEpochStartTriggerFactory.go +++ b/factory/epochStartTrigger/sovereignEpochStartTriggerFactory.go @@ -1,17 +1,12 @@ package epochStartTrigger import ( - "github.com/multiversx/mx-chain-core-go/core/check" - "github.com/multiversx/mx-chain-go/dataRetriever" "github.com/multiversx/mx-chain-go/epochStart" "github.com/multiversx/mx-chain-go/epochStart/metachain" "github.com/multiversx/mx-chain-go/epochStart/shardchain" "github.com/multiversx/mx-chain-go/factory" - "github.com/multiversx/mx-chain-go/process" ) -// TODO: MX-15632 Unit tests + fix import cycle - type sovereignEpochStartTriggerFactory struct { } @@ -23,12 +18,12 @@ func NewSovereignEpochStartTriggerFactory() *sovereignEpochStartTriggerFactory { // CreateEpochStartTrigger creates a meta epoch start trigger for sovereign run type func (f *sovereignEpochStartTriggerFactory) CreateEpochStartTrigger(args factory.ArgsEpochStartTrigger) (epochStart.TriggerHandler, error) { - metaTriggerArgs, err := createMetaEpochStartTriggerArgs(args) + err := checkNilArgs(args) if err != nil { return nil, err } - err = checkNilArgs(args) + metaTriggerArgs, err := createMetaEpochStartTriggerArgs(args) if err != nil { return nil, err } @@ -51,26 +46,6 @@ func (f *sovereignEpochStartTriggerFactory) CreateEpochStartTrigger(args factory return metachain.NewSovereignTrigger(argsSovTrigger) } -func checkNilArgs(args factory.ArgsEpochStartTrigger) error { - if check.IfNil(args.DataComps) { - return process.ErrNilDataComponentsHolder - } - if check.IfNil(args.DataComps.Datapool()) { - return process.ErrNilDataPoolHolder - } - if check.IfNil(args.DataComps.Datapool().MiniBlocks()) { - return dataRetriever.ErrNilMiniblocksPool - } - if check.IfNil(args.DataComps.Datapool().ValidatorsInfo()) { - return process.ErrNilValidatorInfoPool - } - if check.IfNil(args.RequestHandler) { - return process.ErrNilRequestHandler - } - - return nil -} - // IsInterfaceNil checks if the underlying pointer is nil func (f *sovereignEpochStartTriggerFactory) IsInterfaceNil() bool { return f == nil diff --git a/factory/epochStartTrigger/sovereignEpochStartTriggerFactory_test.go b/factory/epochStartTrigger/sovereignEpochStartTriggerFactory_test.go new file mode 100644 index 00000000000..33db15eaf57 --- /dev/null +++ b/factory/epochStartTrigger/sovereignEpochStartTriggerFactory_test.go @@ -0,0 +1,21 @@ +package epochStartTrigger + +import ( + "fmt" + "testing" + + "github.com/multiversx/mx-chain-core-go/core" + "github.com/stretchr/testify/require" +) + +func TestSovereignEpochStartTriggerFactory_CreateEpochStartTrigger(t *testing.T) { + t.Parallel() + + f := NewSovereignEpochStartTriggerFactory() + require.False(t, f.IsInterfaceNil()) + + args := createArgs(core.SovereignChainShardId) + trigger, err := f.CreateEpochStartTrigger(args) + require.Nil(t, err) + require.Equal(t, "*metachain.sovereignTrigger", fmt.Sprintf("%T", trigger)) +} diff --git a/factory/runType/runTypeComponents.go b/factory/runType/runTypeComponents.go index 7b2760d1655..b63df6874bc 100644 --- a/factory/runType/runTypeComponents.go +++ b/factory/runType/runTypeComponents.go @@ -156,79 +156,14 @@ func NewRunTypeComponentsFactory(args ArgsRunTypeComponents) (*runTypeComponents }, nil } -// TODO remove the error from the factories where it's possible - MX-15415 // Create creates the runType components func (rcf *runTypeComponentsFactory) Create() (*runTypeComponents, error) { - blockChainHookHandlerFactory, err := hooks.NewBlockChainHookFactory() - if err != nil { - return nil, fmt.Errorf("runTypeComponentsFactory - NewBlockChainHookFactory failed: %w", err) - } - - epochStartBootstrapperFactory := bootstrap.NewEpochStartBootstrapperFactory() - bootstrapperFromStorageFactory := storageBootstrap.NewShardStorageBootstrapperFactory() - - shardBootstrapFactory, err := storageBootstrap.NewShardBootstrapFactory() - if err != nil { - return nil, fmt.Errorf("runTypeComponentsFactory - NewShardBootstrapFactory failed: %w", err) - } - - blockProcessorFactory, err := block.NewShardBlockProcessorFactory() - if err != nil { - return nil, fmt.Errorf("runTypeComponentsFactory - NewShardBlockProcessorFactory failed: %w", err) - } - - forkDetectorFactory, err := sync.NewShardForkDetectorFactory() - if err != nil { - return nil, fmt.Errorf("runTypeComponentsFactory - NewShardForkDetectorFactory failed: %w", err) - } - - blockTrackerFactory, err := track.NewShardBlockTrackerFactory() - if err != nil { - return nil, fmt.Errorf("runTypeComponentsFactory - NewShardBlockTrackerFactory failed: %w", err) - } - - requestHandlerFactory := requestHandlers.NewResolverRequestHandlerFactory() - - headerValidatorFactory, err := block.NewShardHeaderValidatorFactory() - if err != nil { - return nil, fmt.Errorf("runTypeComponentsFactory - NewShardHeaderValidatorFactory failed: %w", err) - } - - scheduledTxsExecutionFactory, err := preprocess.NewShardScheduledTxsExecutionFactory() - if err != nil { - return nil, fmt.Errorf("runTypeComponentsFactory - NewSovereignScheduledTxsExecutionFactory failed: %w", err) - } - - scResultsPreProcessorCreator, err := preprocess.NewSmartContractResultPreProcessorFactory() - if err != nil { - return nil, fmt.Errorf("runTypeComponentsFactory - NewSmartContractResultPreProcessorFactory failed: %w", err) - } - - transactionCoordinatorFactory, err := coordinator.NewShardTransactionCoordinatorFactory() - if err != nil { - return nil, fmt.Errorf("runTypeComponentsFactory - NewShardTransactionCoordinatorFactory failed: %w", err) - } - - validatorStatisticsProcessorFactory, err := peer.NewValidatorStatisticsProcessorFactory() - if err != nil { - return nil, fmt.Errorf("runTypeComponentsFactory - NewShardBlockProcessorFactory failed: %w", err) - } - - additionalStorageServiceCreator, err := storageFactory.NewShardAdditionalStorageServiceFactory() - if err != nil { - return nil, fmt.Errorf("runTypeComponentsFactory - NewShardAdditionalStorageServiceFactory failed: %w", err) - } - - scProcessorCreator := processProxy.NewSCProcessProxyFactory() - vmContextCreator := systemSmartContracts.NewVMContextCreator() vmContainerMetaCreator, err := factoryVm.NewVmContainerMetaFactory(vmContextCreator) if err != nil { return nil, fmt.Errorf("runTypeComponentsFactory - NewVmContainerMetaFactory failed: %w", err) } - vmContainerShardCreator := factoryVm.NewVmContainerShardFactory() - totalSupply, ok := big.NewInt(0).SetString(rcf.configs.EconomicsConfig.GlobalSettings.GenesisTotalSupply, 10) if !ok { return nil, fmt.Errorf("can not parse total suply from economics.toml, %s is not a valid value", @@ -273,24 +208,24 @@ func (rcf *runTypeComponentsFactory) Create() (*runTypeComponents, error) { } return &runTypeComponents{ - blockChainHookHandlerCreator: blockChainHookHandlerFactory, - epochStartBootstrapperCreator: epochStartBootstrapperFactory, - bootstrapperFromStorageCreator: bootstrapperFromStorageFactory, - bootstrapperCreator: shardBootstrapFactory, - blockProcessorCreator: blockProcessorFactory, - forkDetectorCreator: forkDetectorFactory, - blockTrackerCreator: blockTrackerFactory, - requestHandlerCreator: requestHandlerFactory, - headerValidatorCreator: headerValidatorFactory, - scheduledTxsExecutionCreator: scheduledTxsExecutionFactory, - transactionCoordinatorCreator: transactionCoordinatorFactory, - validatorStatisticsProcessorCreator: validatorStatisticsProcessorFactory, - additionalStorageServiceCreator: additionalStorageServiceCreator, - scProcessorCreator: scProcessorCreator, - scResultPreProcessorCreator: scResultsPreProcessorCreator, + blockChainHookHandlerCreator: hooks.NewBlockChainHookFactory(), + epochStartBootstrapperCreator: bootstrap.NewEpochStartBootstrapperFactory(), + bootstrapperFromStorageCreator: storageBootstrap.NewShardStorageBootstrapperFactory(), + bootstrapperCreator: storageBootstrap.NewShardBootstrapFactory(), + blockProcessorCreator: block.NewShardBlockProcessorFactory(), + forkDetectorCreator: sync.NewShardForkDetectorFactory(), + blockTrackerCreator: track.NewShardBlockTrackerFactory(), + requestHandlerCreator: requestHandlers.NewResolverRequestHandlerFactory(), + headerValidatorCreator: block.NewShardHeaderValidatorFactory(), + scheduledTxsExecutionCreator: preprocess.NewShardScheduledTxsExecutionFactory(), + transactionCoordinatorCreator: coordinator.NewShardTransactionCoordinatorFactory(), + validatorStatisticsProcessorCreator: peer.NewValidatorStatisticsProcessorFactory(), + additionalStorageServiceCreator: storageFactory.NewShardAdditionalStorageServiceFactory(), + scProcessorCreator: processProxy.NewSCProcessProxyFactory(), + scResultPreProcessorCreator: preprocess.NewSmartContractResultPreProcessorFactory(), consensusModel: consensus.ConsensusModelV1, vmContainerMetaFactory: vmContainerMetaCreator, - vmContainerShardFactory: vmContainerShardCreator, + vmContainerShardFactory: factoryVm.NewVmContainerShardFactory(), accountsParser: accountsParser, accountsCreator: accountsCreator, vmContextCreator: vmContextCreator, diff --git a/factory/runType/sovereignRunTypeComponents.go b/factory/runType/sovereignRunTypeComponents.go index a5d6d72f02b..ea2cd0d23ec 100644 --- a/factory/runType/sovereignRunTypeComponents.go +++ b/factory/runType/sovereignRunTypeComponents.go @@ -94,23 +94,6 @@ func (rcf *sovereignRunTypeComponentsFactory) Create() (*runTypeComponents, erro return nil, err } - sovBlockChainHookHandlerFactory, err := hooks.NewSovereignBlockChainHookFactory(rtc.blockChainHookHandlerCreator) - if err != nil { - return nil, fmt.Errorf("sovereignRunTypeComponentsFactory - NewSovereignBlockChainHookFactory failed: %w", err) - } - - epochStartBootstrapperFactory, err := bootstrap.NewSovereignEpochStartBootstrapperFactory(rtc.epochStartBootstrapperCreator) - if err != nil { - return nil, fmt.Errorf("sovereignRunTypeComponentsFactory - NewSovereignEpochStartBootstrapperFactory failed: %w", err) - } - - bootstrapperFromStorageFactory := storageBootstrap.NewSovereignShardStorageBootstrapperFactory() - - bootstrapperFactory, err := storageBootstrap.NewSovereignShardBootstrapFactory(rtc.bootstrapperCreator) - if err != nil { - return nil, fmt.Errorf("sovereignRunTypeComponentsFactory - NewSovereignShardBootstrapFactory failed: %w", err) - } - blockProcessorFactory, err := block.NewSovereignBlockProcessorFactory(rtc.blockProcessorCreator) if err != nil { return nil, fmt.Errorf("sovereignRunTypeComponentsFactory - NewSovereignBlockProcessorFactory failed: %w", err) @@ -136,11 +119,6 @@ func (rcf *sovereignRunTypeComponentsFactory) Create() (*runTypeComponents, erro return nil, fmt.Errorf("sovereignRunTypeComponentsFactory - NewSovereignHeaderValidatorFactory failed: %w", err) } - scheduledTxsExecutionFactory, err := preprocess.NewSovereignScheduledTxsExecutionFactory() - if err != nil { - return nil, fmt.Errorf("sovereignRunTypeComponentsFactory - NewSovereignScheduledTxsExecutionFactory failed: %w", err) - } - transactionCoordinatorFactory, err := coordinator.NewSovereignTransactionCoordinatorFactory(rtc.transactionCoordinatorCreator) if err != nil { return nil, fmt.Errorf("sovereignRunTypeComponentsFactory - NewSovereignTransactionCoordinatorFactory failed: %w", err) @@ -234,16 +212,16 @@ func (rcf *sovereignRunTypeComponentsFactory) Create() (*runTypeComponents, erro } return &runTypeComponents{ - blockChainHookHandlerCreator: sovBlockChainHookHandlerFactory, - epochStartBootstrapperCreator: epochStartBootstrapperFactory, - bootstrapperFromStorageCreator: bootstrapperFromStorageFactory, - bootstrapperCreator: bootstrapperFactory, + blockChainHookHandlerCreator: hooks.NewSovereignBlockChainHookFactory(), + epochStartBootstrapperCreator: bootstrap.NewSovereignEpochStartBootstrapperFactory(), + bootstrapperFromStorageCreator: storageBootstrap.NewSovereignShardStorageBootstrapperFactory(), + bootstrapperCreator: storageBootstrap.NewSovereignShardBootstrapFactory(), blockProcessorCreator: blockProcessorFactory, forkDetectorCreator: forkDetectorFactory, blockTrackerCreator: blockTrackerFactory, requestHandlerCreator: requestHandlerFactory, headerValidatorCreator: headerValidatorFactory, - scheduledTxsExecutionCreator: scheduledTxsExecutionFactory, + scheduledTxsExecutionCreator: preprocess.NewSovereignScheduledTxsExecutionFactory(), transactionCoordinatorCreator: transactionCoordinatorFactory, validatorStatisticsProcessorCreator: validatorStatisticsProcessorFactory, additionalStorageServiceCreator: storageFactory.NewSovereignAdditionalStorageServiceFactory(), diff --git a/go.mod b/go.mod index f28fa96002a..cc6e24b5980 100644 --- a/go.mod +++ b/go.mod @@ -15,7 +15,7 @@ require ( github.com/klauspost/cpuid/v2 v2.2.5 github.com/mitchellh/mapstructure v1.5.0 github.com/multiversx/mx-chain-communication-go v1.1.1 - github.com/multiversx/mx-chain-core-go v1.2.25-0.20250131122047-725dd68e256f + github.com/multiversx/mx-chain-core-go v1.2.25-0.20250206111825-25fbb1b4851c github.com/multiversx/mx-chain-crypto-go v1.2.12 github.com/multiversx/mx-chain-es-indexer-go v1.7.15-0.20250131125841-73868f5ca49c github.com/multiversx/mx-chain-logger-go v1.0.15 diff --git a/go.sum b/go.sum index 89b8d548ae2..12659319155 100644 --- a/go.sum +++ b/go.sum @@ -387,8 +387,8 @@ github.com/multiversx/concurrent-map v0.1.4 h1:hdnbM8VE4b0KYJaGY5yJS2aNIW9TFFsUY github.com/multiversx/concurrent-map v0.1.4/go.mod h1:8cWFRJDOrWHOTNSqgYCUvwT7c7eFQ4U2vKMOp4A/9+o= github.com/multiversx/mx-chain-communication-go v1.1.1 h1:y4DoQeQOJTaSUsRzczQFazf8JYQmInddypApqA3AkwM= github.com/multiversx/mx-chain-communication-go v1.1.1/go.mod h1:WK6bP4pGEHGDDna/AYRIMtl6G9OA0NByI1Lw8PmOnRM= -github.com/multiversx/mx-chain-core-go v1.2.25-0.20250131122047-725dd68e256f h1:iyDk0Zk0n4pHZnrdX30SxevTy+xg9GcEyAmBss45Nfs= -github.com/multiversx/mx-chain-core-go v1.2.25-0.20250131122047-725dd68e256f/go.mod h1:P/YBoFnt25XUaCQ7Q/SD15vhnc9yV5JDhHxyFO9P8Z0= +github.com/multiversx/mx-chain-core-go v1.2.25-0.20250206111825-25fbb1b4851c h1:Cz5b0xd9lbSWGIwmfuPuHqL0e5kTun/PW5NpkVRIAXQ= +github.com/multiversx/mx-chain-core-go v1.2.25-0.20250206111825-25fbb1b4851c/go.mod h1:P/YBoFnt25XUaCQ7Q/SD15vhnc9yV5JDhHxyFO9P8Z0= github.com/multiversx/mx-chain-crypto-go v1.2.12 h1:zWip7rpUS4CGthJxfKn5MZfMfYPjVjIiCID6uX5BSOk= github.com/multiversx/mx-chain-crypto-go v1.2.12/go.mod h1:HzcPpCm1zanNct/6h2rIh+MFrlXbjA5C8+uMyXj3LI4= github.com/multiversx/mx-chain-es-indexer-go v1.7.15-0.20250131125841-73868f5ca49c h1:Qm84hhybDLTeS+BLebFYgmGJpkX+AUnzZsUC+u9KzBU= diff --git a/integrationTests/testProcessorNode.go b/integrationTests/testProcessorNode.go index fb67263fae3..963f18e4a06 100644 --- a/integrationTests/testProcessorNode.go +++ b/integrationTests/testProcessorNode.go @@ -1028,7 +1028,7 @@ func (tpn *TestProcessorNode) createFullSCQueryService(gasMap map[string]map[str argsHook.BlockChain = apiBlockchain esdtTransferParser, _ := parsers.NewESDTTransferParser(TestMarshalizer) - blockChainHookImpl, _ := CreateBlockChainHook(argsHook) + blockChainHookImpl, _ := hooks.NewBlockChainHookImpl(argsHook) argsNewVMFactory := shard.ArgVMContainerFactory{ Config: *vmConfig, BlockChainHook: blockChainHookImpl, @@ -1694,7 +1694,7 @@ func (tpn *TestProcessorNode) initInnerProcessors(gasMap map[string]map[string]u } maxGasLimitPerBlock := uint64(0xFFFFFFFFFFFFFFFF) - blockChainHookImpl, _ := CreateBlockChainHook(argsHook) + blockChainHookImpl, _ := hooks.NewBlockChainHookImpl(argsHook) tpn.EnableEpochs.FailExecutionOnEveryAPIErrorEnableEpoch = 1 argsNewVMFactory := shard.ArgVMContainerFactory{ Config: *vmConfig, @@ -3651,13 +3651,3 @@ func GetDefaultEnableEpochsConfig() *config.EnableEpochs { StakingV4Step2EnableEpoch: UnreachableEpoch, } } - -// CreateBlockChainHook creates a blockchain hook based on the chain run type (normal/sovereign) -func CreateBlockChainHook(args hooks.ArgBlockChainHook) (process.BlockChainHookWithAccountsAdapter, error) { - blockChainHookFactory, err := hooks.NewBlockChainHookFactory() - if err != nil { - return nil, err - } - - return blockChainHookFactory.CreateBlockChainHookHandler(args) -} diff --git a/process/block/preprocess/shardScheduledTxsExecutionFactory.go b/process/block/preprocess/shardScheduledTxsExecutionFactory.go index 2cc1f703e58..80e8d519343 100644 --- a/process/block/preprocess/shardScheduledTxsExecutionFactory.go +++ b/process/block/preprocess/shardScheduledTxsExecutionFactory.go @@ -3,6 +3,7 @@ package preprocess import ( "github.com/multiversx/mx-chain-core-go/hashing" "github.com/multiversx/mx-chain-core-go/marshal" + "github.com/multiversx/mx-chain-go/common" "github.com/multiversx/mx-chain-go/process" "github.com/multiversx/mx-chain-go/sharding" @@ -24,8 +25,8 @@ type shardScheduledTxsExecutionFactory struct { } // NewShardScheduledTxsExecutionFactory creates a new shard scheduled txs execution factory -func NewShardScheduledTxsExecutionFactory() (*shardScheduledTxsExecutionFactory, error) { - return &shardScheduledTxsExecutionFactory{}, nil +func NewShardScheduledTxsExecutionFactory() *shardScheduledTxsExecutionFactory { + return &shardScheduledTxsExecutionFactory{} } // CreateScheduledTxsExecutionHandler creates a new scheduled txs execution handler for shard chain diff --git a/process/block/preprocess/shardScheduledTxsExecutionFactory_test.go b/process/block/preprocess/shardScheduledTxsExecutionFactory_test.go index 8bd9d9b4ef9..397e9e4dff5 100644 --- a/process/block/preprocess/shardScheduledTxsExecutionFactory_test.go +++ b/process/block/preprocess/shardScheduledTxsExecutionFactory_test.go @@ -3,17 +3,17 @@ package preprocess import ( "testing" + "github.com/stretchr/testify/require" + "github.com/multiversx/mx-chain-go/testscommon" commonMock "github.com/multiversx/mx-chain-go/testscommon/common" "github.com/multiversx/mx-chain-go/testscommon/genericMocks" - "github.com/stretchr/testify/require" ) func TestNewShardScheduledTxsExecutionFactory(t *testing.T) { t.Parallel() - stef, err := NewShardScheduledTxsExecutionFactory() - require.Nil(t, err) + stef := NewShardScheduledTxsExecutionFactory() require.NotNil(t, stef) require.IsType(t, &shardScheduledTxsExecutionFactory{}, stef) } @@ -21,7 +21,7 @@ func TestNewShardScheduledTxsExecutionFactory(t *testing.T) { func TestShardScheduledTxsExecutionFactory_CreateScheduledTxsExecutionHandler(t *testing.T) { t.Parallel() - stef, _ := NewShardScheduledTxsExecutionFactory() + stef := NewShardScheduledTxsExecutionFactory() stxeh, err := stef.CreateScheduledTxsExecutionHandler(ScheduledTxsExecutionFactoryArgs{}) require.NotNil(t, err) @@ -44,6 +44,6 @@ func TestShardScheduledTxsExecutionFactory_CreateScheduledTxsExecutionHandler(t func TestShardScheduledTxsExecutionFactory_IsInterfaceNil(t *testing.T) { t.Parallel() - stef, _ := NewShardScheduledTxsExecutionFactory() + stef := NewShardScheduledTxsExecutionFactory() require.False(t, stef.IsInterfaceNil()) } diff --git a/process/block/preprocess/smartContractResultPreProcessorFactory.go b/process/block/preprocess/smartContractResultPreProcessorFactory.go index 5011cc32eae..ef3e41e10d9 100644 --- a/process/block/preprocess/smartContractResultPreProcessorFactory.go +++ b/process/block/preprocess/smartContractResultPreProcessorFactory.go @@ -6,8 +6,8 @@ type smartContractResultPreProcessorFactory struct { } // NewSmartContractResultPreProcessorFactory creates a new smart contract result pre processor factory -func NewSmartContractResultPreProcessorFactory() (*smartContractResultPreProcessorFactory, error) { - return &smartContractResultPreProcessorFactory{}, nil +func NewSmartContractResultPreProcessorFactory() *smartContractResultPreProcessorFactory { + return &smartContractResultPreProcessorFactory{} } // CreateSmartContractResultPreProcessor creates a new smart contract result pre processor diff --git a/process/block/preprocess/smartContractResultPreProcessorFactory_test.go b/process/block/preprocess/smartContractResultPreProcessorFactory_test.go index ffd74decdf6..4ae38d8c3cb 100644 --- a/process/block/preprocess/smartContractResultPreProcessorFactory_test.go +++ b/process/block/preprocess/smartContractResultPreProcessorFactory_test.go @@ -1,28 +1,28 @@ package preprocess_test import ( - "github.com/multiversx/mx-chain-go/testscommon/common" "testing" "github.com/multiversx/mx-chain-core-go/data/smartContractResult" + vmcommon "github.com/multiversx/mx-chain-vm-common-go" + "github.com/stretchr/testify/require" + "github.com/multiversx/mx-chain-go/process" "github.com/multiversx/mx-chain-go/process/block/preprocess" "github.com/multiversx/mx-chain-go/process/mock" "github.com/multiversx/mx-chain-go/testscommon" + "github.com/multiversx/mx-chain-go/testscommon/common" "github.com/multiversx/mx-chain-go/testscommon/economicsmocks" "github.com/multiversx/mx-chain-go/testscommon/enableEpochsHandlerMock" "github.com/multiversx/mx-chain-go/testscommon/hashingMocks" stateMock "github.com/multiversx/mx-chain-go/testscommon/state" storageStubs "github.com/multiversx/mx-chain-go/testscommon/storage" - vmcommon "github.com/multiversx/mx-chain-vm-common-go" - "github.com/stretchr/testify/require" ) func TestNewSmartContractResultPreProcessorFactory(t *testing.T) { t.Parallel() - fact, err := preprocess.NewSmartContractResultPreProcessorFactory() - require.Nil(t, err) + fact := preprocess.NewSmartContractResultPreProcessorFactory() require.NotNil(t, fact) require.Implements(t, new(preprocess.SmartContractResultPreProcessorCreator), fact) } @@ -30,7 +30,7 @@ func TestNewSmartContractResultPreProcessorFactory(t *testing.T) { func TestSmartContractResultPreProcessorFactory_CreateSmartContractResultPreProcessor(t *testing.T) { t.Parallel() - fact, _ := preprocess.NewSmartContractResultPreProcessorFactory() + fact := preprocess.NewSmartContractResultPreProcessorFactory() args := preprocess.SmartContractResultPreProcessorCreatorArgs{} preProcessor, err := fact.CreateSmartContractResultPreProcessor(args) @@ -47,7 +47,7 @@ func TestSmartContractResultPreProcessorFactory_CreateSmartContractResultPreProc func TestSmartContractResultPreProcessorFactory_IsInterfaceNil(t *testing.T) { t.Parallel() - fact, _ := preprocess.NewSmartContractResultPreProcessorFactory() + fact := preprocess.NewSmartContractResultPreProcessorFactory() require.False(t, fact.IsInterfaceNil()) } diff --git a/process/block/preprocess/sovereignScheduledTxsExecutionFactory.go b/process/block/preprocess/sovereignScheduledTxsExecutionFactory.go index db295077d28..9ab7d9df745 100644 --- a/process/block/preprocess/sovereignScheduledTxsExecutionFactory.go +++ b/process/block/preprocess/sovereignScheduledTxsExecutionFactory.go @@ -9,8 +9,8 @@ type sovereignScheduledTxsExecutionFactory struct { } // NewSovereignScheduledTxsExecutionFactory creates a new sovereign scheduled txs execution factory -func NewSovereignScheduledTxsExecutionFactory() (*sovereignScheduledTxsExecutionFactory, error) { - return &sovereignScheduledTxsExecutionFactory{}, nil +func NewSovereignScheduledTxsExecutionFactory() *sovereignScheduledTxsExecutionFactory { + return &sovereignScheduledTxsExecutionFactory{} } // CreateScheduledTxsExecutionHandler creates a new scheduled txs execution handler for sovereign chain diff --git a/process/block/preprocess/sovereignScheduledTxsExecutionFactory_test.go b/process/block/preprocess/sovereignScheduledTxsExecutionFactory_test.go index 85bca3aa491..2de4db3cc1c 100644 --- a/process/block/preprocess/sovereignScheduledTxsExecutionFactory_test.go +++ b/process/block/preprocess/sovereignScheduledTxsExecutionFactory_test.go @@ -1,35 +1,26 @@ package preprocess import ( + "fmt" "testing" - "github.com/multiversx/mx-chain-go/process" "github.com/stretchr/testify/require" ) func TestNewSovereignScheduledTxsExecutionFactory(t *testing.T) { t.Parallel() - stef, err := NewSovereignScheduledTxsExecutionFactory() - require.Nil(t, err) - require.NotNil(t, stef) + stef := NewSovereignScheduledTxsExecutionFactory() require.IsType(t, &sovereignScheduledTxsExecutionFactory{}, stef) + require.False(t, stef.IsInterfaceNil()) } func TestSovereignScheduledTxsExecutionFactory_CreateScheduledTxsExecutionHandler(t *testing.T) { t.Parallel() - stef, _ := NewSovereignScheduledTxsExecutionFactory() + stef := NewSovereignScheduledTxsExecutionFactory() stxeh, err := stef.CreateScheduledTxsExecutionHandler(ScheduledTxsExecutionFactoryArgs{}) require.Nil(t, err) - require.NotNil(t, stxeh) - require.Implements(t, new(process.ScheduledTxsExecutionHandler), stxeh) -} - -func TestSovereignScheduledTxsExecutionFactory_IsInterfaceNil(t *testing.T) { - t.Parallel() - - stef, _ := NewSovereignScheduledTxsExecutionFactory() - require.False(t, stef.IsInterfaceNil()) + require.Equal(t, "*disabled.ScheduledTxsExecutionHandler", fmt.Sprintf("%T", stxeh)) } diff --git a/process/block/preprocess/sovereignSmartContractResultPreProcessorFactory_test.go b/process/block/preprocess/sovereignSmartContractResultPreProcessorFactory_test.go index c3404ba339c..62eb318fee7 100644 --- a/process/block/preprocess/sovereignSmartContractResultPreProcessorFactory_test.go +++ b/process/block/preprocess/sovereignSmartContractResultPreProcessorFactory_test.go @@ -3,9 +3,10 @@ package preprocess_test import ( "testing" + "github.com/stretchr/testify/require" + "github.com/multiversx/mx-chain-go/process" "github.com/multiversx/mx-chain-go/process/block/preprocess" - "github.com/stretchr/testify/require" ) func TestNewSovereignContractResultPreProcessorFactory(t *testing.T) { @@ -15,7 +16,7 @@ func TestNewSovereignContractResultPreProcessorFactory(t *testing.T) { require.NotNil(t, err) require.Nil(t, sovFact) - fact, _ := preprocess.NewSmartContractResultPreProcessorFactory() + fact := preprocess.NewSmartContractResultPreProcessorFactory() sovFact, err = preprocess.NewSovereignSmartContractResultPreProcessorFactory(fact) require.Nil(t, err) require.NotNil(t, sovFact) @@ -25,7 +26,7 @@ func TestNewSovereignContractResultPreProcessorFactory(t *testing.T) { func TestSovereignContractResultPreProcessorFactory_CreateSmartContractResultPreProcessor(t *testing.T) { t.Parallel() - f, _ := preprocess.NewSmartContractResultPreProcessorFactory() + f := preprocess.NewSmartContractResultPreProcessorFactory() fact, _ := preprocess.NewSovereignSmartContractResultPreProcessorFactory(f) args := preprocess.SmartContractResultPreProcessorCreatorArgs{} @@ -43,7 +44,7 @@ func TestSovereignContractResultPreProcessorFactory_CreateSmartContractResultPre func TestSovereignContractResultPreProcessorFactory_IsInterfaceNil(t *testing.T) { t.Parallel() - f, _ := preprocess.NewSmartContractResultPreProcessorFactory() + f := preprocess.NewSmartContractResultPreProcessorFactory() fact, _ := preprocess.NewSovereignSmartContractResultPreProcessorFactory(f) require.False(t, fact.IsInterfaceNil()) } diff --git a/process/block/shardBlockProcessorFactory.go b/process/block/shardBlockProcessorFactory.go index 9245f5b095e..028578b3686 100644 --- a/process/block/shardBlockProcessorFactory.go +++ b/process/block/shardBlockProcessorFactory.go @@ -10,8 +10,8 @@ type shardBlockProcessorFactory struct { } // NewShardBlockProcessorFactory creates a new shard block processor factory -func NewShardBlockProcessorFactory() (*shardBlockProcessorFactory, error) { - return &shardBlockProcessorFactory{}, nil +func NewShardBlockProcessorFactory() *shardBlockProcessorFactory { + return &shardBlockProcessorFactory{} } // CreateBlockProcessor creates a new shard block processor for the chain run type normal diff --git a/process/block/shardBlockProcessorFactory_test.go b/process/block/shardBlockProcessorFactory_test.go index 41f20362f36..cbbba9e2ec2 100644 --- a/process/block/shardBlockProcessorFactory_test.go +++ b/process/block/shardBlockProcessorFactory_test.go @@ -3,25 +3,25 @@ package block_test import ( "testing" - "github.com/multiversx/mx-chain-go/process" - "github.com/multiversx/mx-chain-go/process/block" vmcommon "github.com/multiversx/mx-chain-vm-common-go" "github.com/stretchr/testify/require" + + "github.com/multiversx/mx-chain-go/process" + "github.com/multiversx/mx-chain-go/process/block" ) func TestNewShardBlockProcessorFactory(t *testing.T) { t.Parallel() - sbpf, err := block.NewShardBlockProcessorFactory() + sbpf := block.NewShardBlockProcessorFactory() require.NotNil(t, sbpf) - require.Nil(t, err) require.Implements(t, new(block.BlockProcessorCreator), sbpf) } func TestShardBlockProcessorFactory_CreateBlockProcessor(t *testing.T) { t.Parallel() - sbpf, _ := block.NewShardBlockProcessorFactory() + sbpf := block.NewShardBlockProcessorFactory() funcCreateMetaArgs := func(systemVM vmcommon.VMExecutionHandler) (*block.ExtraArgsMetaBlockProcessor, error) { return nil, nil @@ -47,6 +47,6 @@ func TestShardBlockProcessorFactory_CreateBlockProcessor(t *testing.T) { func TestShardBlockProcessorFactory_IsInterfaceNil(t *testing.T) { t.Parallel() - sbpf, _ := block.NewShardBlockProcessorFactory() + sbpf := block.NewShardBlockProcessorFactory() require.False(t, sbpf.IsInterfaceNil()) } diff --git a/process/block/shardHeaderValidatorFactory.go b/process/block/shardHeaderValidatorFactory.go index 71ee455dd6d..aa0d2385aac 100644 --- a/process/block/shardHeaderValidatorFactory.go +++ b/process/block/shardHeaderValidatorFactory.go @@ -6,8 +6,8 @@ type shardHeaderValidatorFactory struct { } // NewShardHeaderValidatorFactory creates a new shard header validator factory -func NewShardHeaderValidatorFactory() (*shardHeaderValidatorFactory, error) { - return &shardHeaderValidatorFactory{}, nil +func NewShardHeaderValidatorFactory() *shardHeaderValidatorFactory { + return &shardHeaderValidatorFactory{} } // CreateHeaderValidator creates a new header validator for the chain run type normal diff --git a/process/block/shardHeaderValidatorFactory_test.go b/process/block/shardHeaderValidatorFactory_test.go index e791a252267..d4346ebc661 100644 --- a/process/block/shardHeaderValidatorFactory_test.go +++ b/process/block/shardHeaderValidatorFactory_test.go @@ -3,16 +3,16 @@ package block import ( "testing" + "github.com/stretchr/testify/require" + "github.com/multiversx/mx-chain-go/process" "github.com/multiversx/mx-chain-go/testscommon" - "github.com/stretchr/testify/require" ) func TestNewShardHeaderValidatorFactory(t *testing.T) { t.Parallel() - shvf, err := NewShardHeaderValidatorFactory() - require.Nil(t, err) + shvf := NewShardHeaderValidatorFactory() require.NotNil(t, shvf) require.Implements(t, new(HeaderValidatorCreator), shvf) } @@ -20,7 +20,7 @@ func TestNewShardHeaderValidatorFactory(t *testing.T) { func TestShardHeaderValidatorFactory_CreateHeaderValidator(t *testing.T) { t.Parallel() - shvf, _ := NewShardHeaderValidatorFactory() + shvf := NewShardHeaderValidatorFactory() hv, err := shvf.CreateHeaderValidator(ArgsHeaderValidator{ Hasher: nil, @@ -41,6 +41,6 @@ func TestShardHeaderValidatorFactory_CreateHeaderValidator(t *testing.T) { func TestShardHeaderValidatorFactory_IsInterfaceNil(t *testing.T) { t.Parallel() - shvf, _ := NewShardHeaderValidatorFactory() + shvf := NewShardHeaderValidatorFactory() require.False(t, shvf.IsInterfaceNil()) } diff --git a/process/block/sovereignBlockProcessorFactory_test.go b/process/block/sovereignBlockProcessorFactory_test.go index 0f5029edf69..5f76754f8d2 100644 --- a/process/block/sovereignBlockProcessorFactory_test.go +++ b/process/block/sovereignBlockProcessorFactory_test.go @@ -3,12 +3,13 @@ package block_test import ( "testing" + vmcommon "github.com/multiversx/mx-chain-vm-common-go" + "github.com/stretchr/testify/require" + "github.com/multiversx/mx-chain-go/process" "github.com/multiversx/mx-chain-go/process/block" "github.com/multiversx/mx-chain-go/process/mock" "github.com/multiversx/mx-chain-go/testscommon" - vmcommon "github.com/multiversx/mx-chain-vm-common-go" - "github.com/stretchr/testify/require" ) func TestNewSovereignBlockProcessorFactory(t *testing.T) { @@ -19,7 +20,7 @@ func TestNewSovereignBlockProcessorFactory(t *testing.T) { require.Nil(t, sbpf) require.NotNil(t, err) - shardFactory, _ := block.NewShardBlockProcessorFactory() + shardFactory := block.NewShardBlockProcessorFactory() sbpf, err = block.NewSovereignBlockProcessorFactory(shardFactory) require.NotNil(t, sbpf) @@ -30,7 +31,7 @@ func TestNewSovereignBlockProcessorFactory(t *testing.T) { func TestSovereignBlockProcessorFactory_CreateBlockProcessor(t *testing.T) { t.Parallel() - shardFactory, _ := block.NewShardBlockProcessorFactory() + shardFactory := block.NewShardBlockProcessorFactory() sbpf, _ := block.NewSovereignBlockProcessorFactory(shardFactory) funcCreateMetaArgs := func(systemVM vmcommon.VMExecutionHandler) (*block.ExtraArgsMetaBlockProcessor, error) { @@ -65,7 +66,7 @@ func TestSovereignBlockProcessorFactory_CreateBlockProcessor(t *testing.T) { func TestSovereignBlockProcessorFactory_IsInterfaceNil(t *testing.T) { t.Parallel() - shardFactory, _ := block.NewShardBlockProcessorFactory() + shardFactory := block.NewShardBlockProcessorFactory() sbpf, _ := block.NewSovereignBlockProcessorFactory(shardFactory) require.False(t, sbpf.IsInterfaceNil()) } diff --git a/process/block/sovereignChainBlock.go b/process/block/sovereignChainBlock.go index 9e5597bd858..9222739664c 100644 --- a/process/block/sovereignChainBlock.go +++ b/process/block/sovereignChainBlock.go @@ -245,6 +245,11 @@ func (scbp *sovereignChainBlockProcessor) CreateBlock(initialHdr data.HeaderHand return nil, nil, err } + err = scbp.createEpochStartDataCrossChain(sovereignChainHeaderHandler) + if err != nil { + return nil, nil, err + } + scbp.blockChainHook.SetCurrentHeader(initialHdr) scbp.requestHandler.SetEpoch(initialHdr.GetEpoch()) return initialHdr, &block.Body{}, nil @@ -676,12 +681,60 @@ func (scbp *sovereignChainBlockProcessor) requestExtendedShardHeaders(sovereignC _ = core.EmptyChannel(scbp.chRcvAllExtendedShardHdrs) if len(sovereignChainHeader.GetExtendedShardHeaderHashes()) == 0 { - return 0 + return scbp.computeAndRequestEpochStartExtendedHeaderIfMissing(sovereignChainHeader) } return scbp.computeExistingAndRequestMissingExtendedShardHeaders(sovereignChainHeader) } +func (scbp *sovereignChainBlockProcessor) computeAndRequestEpochStartExtendedHeaderIfMissing(sovereignChainHeader data.SovereignChainHeaderHandler) uint32 { + if !sovereignChainHeader.IsStartOfEpochBlock() { + return 0 + } + + lastCrossChainData := sovereignChainHeader.GetLastFinalizedCrossChainHeaderHandler() + shouldCheckEpochStartCrossChainHash := lastCrossChainData != nil && len(lastCrossChainData.GetHeaderHash()) != 0 + if !shouldCheckEpochStartCrossChainHash { + return 0 + } + + lastCrossChainHash := lastCrossChainData.GetHeaderHash() + if !scbp.shouldRequestEpochStartCrossChainHash(lastCrossChainHash) { + return 0 + } + + scbp.hdrsForCurrBlock.mutHdrsForBlock.Lock() + scbp.hdrsForCurrBlock.missingHdrs++ + scbp.hdrsForCurrBlock.hdrHashAndInfo[string(lastCrossChainHash)] = &hdrInfo{ + hdr: nil, + usedInBlock: false, + } + scbp.hdrsForCurrBlock.mutHdrsForBlock.Unlock() + + go scbp.extendedShardHeaderRequester.RequestExtendedShardHeader(lastCrossChainHash) + + return 1 +} + +func (scbp *sovereignChainBlockProcessor) shouldRequestEpochStartCrossChainHash(lastCrossChainHash []byte) bool { + _, errMissingHdrPool := process.GetExtendedShardHeaderFromPool( + lastCrossChainHash, + scbp.dataPool.Headers()) + _, lastNotarizedHdrHash, _ := scbp.blockTracker.GetLastCrossNotarizedHeader(core.MainChainShardId) + + missingHeaderInTracker := !bytes.Equal(lastNotarizedHdrHash, lastCrossChainHash) + missingHeaderInPool := errMissingHdrPool != nil + shouldRequestLastCrossChainHeader := missingHeaderInTracker || missingHeaderInPool + + log.Debug("sovereignChainBlockProcessor.checkAndRequestIfMissingEpochStartExtendedHeader", + "missingHeaderInTracker", missingHeaderInTracker, + "missingHeaderInPool", missingHeaderInPool, + "shouldRequestLastCrossChainHeader", shouldRequestLastCrossChainHeader, + ) + + return shouldRequestLastCrossChainHeader +} + func (scbp *sovereignChainBlockProcessor) computeExistingAndRequestMissingExtendedShardHeaders(sovereignChainHeader data.SovereignChainHeaderHandler) uint32 { scbp.hdrsForCurrBlock.mutHdrsForBlock.Lock() defer scbp.hdrsForCurrBlock.mutHdrsForBlock.Unlock() @@ -745,7 +798,7 @@ func (scbp *sovereignChainBlockProcessor) ProcessBlock(headerHandler data.Header "nonce", headerHandler.GetNonce(), ) - sovereignChainHeader, ok := headerHandler.(data.SovereignChainHeaderHandler) + sovChainHeader, ok := headerHandler.(data.SovereignChainHeaderHandler) if !ok { return nil, nil, process.ErrWrongTypeAssertion } @@ -772,7 +825,7 @@ func (scbp *sovereignChainBlockProcessor) ProcessBlock(headerHandler data.Header scbp.blockChainHook.SetCurrentHeader(headerHandler) scbp.txCoordinator.RequestBlockTransactions(body) - requestedExtendedShardHdrs := scbp.requestExtendedShardHeaders(sovereignChainHeader) + requestedExtendedShardHdrs := scbp.requestExtendedShardHeaders(sovChainHeader) if haveTime() < 0 { return nil, nil, process.ErrTimeIsOut @@ -799,7 +852,7 @@ func (scbp *sovereignChainBlockProcessor) ProcessBlock(headerHandler data.Header go scbp.checkAndRequestIfExtendedShardHeadersMissing() }() - err = scbp.checkExtendedShardHeadersValidity() + err = scbp.checkExtendedShardHeadersValidity(sovChainHeader) if err != nil { return nil, nil, err } @@ -840,7 +893,7 @@ func (scbp *sovereignChainBlockProcessor) ProcessBlock(headerHandler data.Header return nil, nil, err } - err = scbp.verifySovereignPostProcessBlock(headerHandler, newBody, sovereignChainHeader) + err = scbp.verifySovereignPostProcessBlock(headerHandler, newBody, sovChainHeader) if err != nil { return nil, nil, err } @@ -849,7 +902,7 @@ func (scbp *sovereignChainBlockProcessor) ProcessBlock(headerHandler data.Header } // checkExtendedShardHeadersValidity checks if used extended shard headers are valid as construction -func (scbp *sovereignChainBlockProcessor) checkExtendedShardHeadersValidity() error { +func (scbp *sovereignChainBlockProcessor) checkExtendedShardHeadersValidity(sovereignChainHeader data.SovereignChainHeaderHandler) error { lastCrossNotarizedHeader, _, err := scbp.blockTracker.GetLastCrossNotarizedHeader(core.MainChainShardId) if err != nil { return err @@ -865,6 +918,11 @@ func (scbp *sovereignChainBlockProcessor) checkExtendedShardHeadersValidity() er return nil } + // we should not have an epoch start block with main chain headers to be processed + if sovereignChainHeader.IsStartOfEpochBlock() { + return errors.ErrReceivedSovereignEpochStartBlockWithExtendedHeaders + } + if scbp.isGenesisHeaderWithNoPreviousTracking(extendedShardHdrs[0]) { // we are missing pre-genesis header, so we can't link it to previous header if len(extendedShardHdrs) == 1 { @@ -992,7 +1050,7 @@ func (scbp *sovereignChainBlockProcessor) processEpochStartMetaBlock( return scbp.applyBodyToHeaderForEpochChange(header, body) } -func (scbp *sovereignChainBlockProcessor) createEpochStartDataCrossChain(sovHdr *block.SovereignChainHeader) error { +func (scbp *sovereignChainBlockProcessor) createEpochStartDataCrossChain(sovHdr data.SovereignChainHeaderHandler) error { lastCrossNotarizedHeader, lastCrossNotarizedHeaderHash, err := scbp.blockTracker.GetLastCrossNotarizedHeader(core.MainChainShardId) if err != nil { return err @@ -1009,15 +1067,13 @@ func (scbp *sovereignChainBlockProcessor) createEpochStartDataCrossChain(sovHdr "lastCrossNotarizedHeaderNonce", lastCrossNotarizedHeader.GetNonce(), ) - sovHdr.EpochStart.LastFinalizedCrossChainHeader = block.EpochStartCrossChainData{ + return sovHdr.SetLastFinalizedCrossChainHeaderHandler(&block.EpochStartCrossChainData{ ShardID: core.MainChainShardId, Epoch: lastCrossNotarizedHeader.GetEpoch(), Round: lastCrossNotarizedHeader.GetRound(), Nonce: lastCrossNotarizedHeader.GetNonce(), HeaderHash: lastCrossNotarizedHeaderHash, - } - - return nil + }) } func (scbp *sovereignChainBlockProcessor) applyBodyToHeaderForEpochChange(header data.HeaderHandler, body *block.Body) error { @@ -1122,7 +1178,9 @@ func (scbp *sovereignChainBlockProcessor) sortExtendedShardHeadersForCurrentBloc scbp.hdrsForCurrBlock.mutHdrsForBlock.RLock() for _, headerInfo := range scbp.hdrsForCurrBlock.hdrHashAndInfo { - hdrsForCurrentBlock = append(hdrsForCurrentBlock, headerInfo.hdr) + if headerInfo.usedInBlock { + hdrsForCurrentBlock = append(hdrsForCurrentBlock, headerInfo.hdr) + } } scbp.hdrsForCurrBlock.mutHdrsForBlock.RUnlock() diff --git a/process/block/sovereignChainHeaderValidatorFactory_test.go b/process/block/sovereignChainHeaderValidatorFactory_test.go index a9ed1097e30..7e19d5502d8 100644 --- a/process/block/sovereignChainHeaderValidatorFactory_test.go +++ b/process/block/sovereignChainHeaderValidatorFactory_test.go @@ -3,9 +3,10 @@ package block import ( "testing" + "github.com/stretchr/testify/require" + "github.com/multiversx/mx-chain-go/process" "github.com/multiversx/mx-chain-go/testscommon" - "github.com/stretchr/testify/require" ) func TestNewSovereignHeaderValidatorFactory(t *testing.T) { @@ -15,7 +16,7 @@ func TestNewSovereignHeaderValidatorFactory(t *testing.T) { require.NotNil(t, err) require.Nil(t, shvf) - sf, _ := NewShardHeaderValidatorFactory() + sf := NewShardHeaderValidatorFactory() shvf, err = NewSovereignHeaderValidatorFactory(sf) require.Nil(t, err) require.NotNil(t, shvf) @@ -25,7 +26,7 @@ func TestNewSovereignHeaderValidatorFactory(t *testing.T) { func TestSovereignHeaderValidatorFactory_CreateHeaderValidator(t *testing.T) { t.Parallel() - sf, _ := NewShardHeaderValidatorFactory() + sf := NewShardHeaderValidatorFactory() shvf, _ := NewSovereignHeaderValidatorFactory(sf) hv, err := shvf.CreateHeaderValidator(ArgsHeaderValidator{ @@ -47,7 +48,7 @@ func TestSovereignHeaderValidatorFactory_CreateHeaderValidator(t *testing.T) { func TestSovereignHeaderValidatorFactory_IsInterfaceNil(t *testing.T) { t.Parallel() - sf, _ := NewShardHeaderValidatorFactory() + sf := NewShardHeaderValidatorFactory() shvf, _ := NewSovereignHeaderValidatorFactory(sf) require.False(t, shvf.IsInterfaceNil()) } diff --git a/process/coordinator/shardTransactionCoordinatorFactory.go b/process/coordinator/shardTransactionCoordinatorFactory.go index c6ab43a3b54..b7a7bf13d05 100644 --- a/process/coordinator/shardTransactionCoordinatorFactory.go +++ b/process/coordinator/shardTransactionCoordinatorFactory.go @@ -6,8 +6,8 @@ type shardTransactionCoordinatorFactory struct { } // NewShardTransactionCoordinatorFactory creates a new sovereign transaction coordinator factory -func NewShardTransactionCoordinatorFactory() (*shardTransactionCoordinatorFactory, error) { - return &shardTransactionCoordinatorFactory{}, nil +func NewShardTransactionCoordinatorFactory() *shardTransactionCoordinatorFactory { + return &shardTransactionCoordinatorFactory{} } // CreateTransactionCoordinator creates a new transaction coordinator for the chain run type normal diff --git a/process/coordinator/shardTransactionCoordinatorFactory_test.go b/process/coordinator/shardTransactionCoordinatorFactory_test.go index 9c3a3870f87..489eaac2216 100644 --- a/process/coordinator/shardTransactionCoordinatorFactory_test.go +++ b/process/coordinator/shardTransactionCoordinatorFactory_test.go @@ -9,9 +9,7 @@ import ( func TestShardTransactionCoordinatorFactory_NewShardTransactionCoordinatorFactory(t *testing.T) { t.Parallel() - tcf, err := NewShardTransactionCoordinatorFactory() - - require.Nil(t, err) + tcf := NewShardTransactionCoordinatorFactory() require.NotNil(t, tcf) require.IsType(t, new(shardTransactionCoordinatorFactory), tcf) } @@ -19,7 +17,7 @@ func TestShardTransactionCoordinatorFactory_NewShardTransactionCoordinatorFactor func TestShardTransactionCoordinatorFactory_CreateTransactionCoordinator(t *testing.T) { t.Parallel() - tcf, _ := NewShardTransactionCoordinatorFactory() + tcf := NewShardTransactionCoordinatorFactory() tc, err := tcf.CreateTransactionCoordinator(ArgTransactionCoordinator{}) require.NotNil(t, err) require.Nil(t, tc) @@ -33,6 +31,6 @@ func TestShardTransactionCoordinatorFactory_CreateTransactionCoordinator(t *test func TestShardTransactionCoordinatorFactory_IsInterfaceNil(t *testing.T) { t.Parallel() - tcf, _ := NewShardTransactionCoordinatorFactory() + tcf := NewShardTransactionCoordinatorFactory() require.False(t, tcf.IsInterfaceNil()) } diff --git a/process/coordinator/sovereignTransactionCoordinatorFactory_test.go b/process/coordinator/sovereignTransactionCoordinatorFactory_test.go index cf724c3454e..eb769d06ea1 100644 --- a/process/coordinator/sovereignTransactionCoordinatorFactory_test.go +++ b/process/coordinator/sovereignTransactionCoordinatorFactory_test.go @@ -3,8 +3,9 @@ package coordinator import ( "testing" - "github.com/multiversx/mx-chain-go/process" "github.com/stretchr/testify/require" + + "github.com/multiversx/mx-chain-go/process" ) func TestSovereignTransactionCoordinatorFactory_NewShardTransactionCoordinatorFactory(t *testing.T) { @@ -14,7 +15,7 @@ func TestSovereignTransactionCoordinatorFactory_NewShardTransactionCoordinatorFa require.Equal(t, process.ErrNilTransactionCoordinatorCreator, err) require.Nil(t, sovtcf) - stcf, _ := NewShardTransactionCoordinatorFactory() + stcf := NewShardTransactionCoordinatorFactory() sovtcf, err = NewSovereignTransactionCoordinatorFactory(stcf) require.Nil(t, err) @@ -25,7 +26,7 @@ func TestSovereignTransactionCoordinatorFactory_NewShardTransactionCoordinatorFa func TestSovereignTransactionCoordinatorFactory_CreateTransactionCoordinator(t *testing.T) { t.Parallel() - stcf, _ := NewShardTransactionCoordinatorFactory() + stcf := NewShardTransactionCoordinatorFactory() sovtcf, _ := NewSovereignTransactionCoordinatorFactory(stcf) tc, err := sovtcf.CreateTransactionCoordinator(ArgTransactionCoordinator{}) require.NotNil(t, err) @@ -40,7 +41,7 @@ func TestSovereignTransactionCoordinatorFactory_CreateTransactionCoordinator(t * func TestSovereignTransactionCoordinatorFactory_IsInterfaceNil(t *testing.T) { t.Parallel() - stcf, _ := NewShardTransactionCoordinatorFactory() + stcf := NewShardTransactionCoordinatorFactory() sovtcf, _ := NewSovereignTransactionCoordinatorFactory(stcf) require.False(t, sovtcf.IsInterfaceNil()) } diff --git a/process/factory/shard/preProcessorsContainerFactory_test.go b/process/factory/shard/preProcessorsContainerFactory_test.go index 19ff98ea42d..d22909bf7a9 100644 --- a/process/factory/shard/preProcessorsContainerFactory_test.go +++ b/process/factory/shard/preProcessorsContainerFactory_test.go @@ -4,6 +4,9 @@ import ( "fmt" "testing" + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" + "github.com/multiversx/mx-chain-go/dataRetriever" customErrors "github.com/multiversx/mx-chain-go/errors" "github.com/multiversx/mx-chain-go/process" @@ -19,8 +22,6 @@ import ( "github.com/multiversx/mx-chain-go/testscommon/processMocks" stateMock "github.com/multiversx/mx-chain-go/testscommon/state" storageStubs "github.com/multiversx/mx-chain-go/testscommon/storage" - "github.com/stretchr/testify/assert" - "github.com/stretchr/testify/require" ) func createMockPubkeyConverter() *testscommon.PubkeyConverterMock { @@ -384,7 +385,7 @@ func TestPreProcessorsContainerFactory_CreateSCRPreprocessor(t *testing.T) { t.Parallel() args := createMockPreProcessorsContainerFactoryArguments() - scrppf, _ := preprocess.NewSmartContractResultPreProcessorFactory() + scrppf := preprocess.NewSmartContractResultPreProcessorFactory() runTypeComps := processMocks.NewRunTypeComponentsStub() runTypeComps.SCResultsPreProcessorFactory, _ = preprocess.NewSovereignSmartContractResultPreProcessorFactory(scrppf) args.RunTypeComponents = runTypeComps diff --git a/process/peer/sovereignValidatorStatisticsProcessorFactory_test.go b/process/peer/sovereignValidatorStatisticsProcessorFactory_test.go index db670ecf6c0..c73a13a5511 100644 --- a/process/peer/sovereignValidatorStatisticsProcessorFactory_test.go +++ b/process/peer/sovereignValidatorStatisticsProcessorFactory_test.go @@ -3,9 +3,10 @@ package peer_test import ( "testing" + "github.com/stretchr/testify/require" + "github.com/multiversx/mx-chain-go/process" "github.com/multiversx/mx-chain-go/process/peer" - "github.com/stretchr/testify/require" ) func TestNewSovereignValidatorStatisticsProcessorFactory(t *testing.T) { @@ -15,7 +16,7 @@ func TestNewSovereignValidatorStatisticsProcessorFactory(t *testing.T) { require.NotNil(t, err) require.Nil(t, vspf) - vs, _ := peer.NewValidatorStatisticsProcessorFactory() + vs := peer.NewValidatorStatisticsProcessorFactory() vspf, err = peer.NewSovereignValidatorStatisticsProcessorFactory(vs) require.Nil(t, err) require.NotNil(t, vspf) @@ -25,7 +26,7 @@ func TestNewSovereignValidatorStatisticsProcessorFactory(t *testing.T) { func TestSovereignValidatorStatisticsProcessorFactory_CreateValidatorStatisticsProcessor(t *testing.T) { t.Parallel() - vs, _ := peer.NewValidatorStatisticsProcessorFactory() + vs := peer.NewValidatorStatisticsProcessorFactory() vspf, _ := peer.NewSovereignValidatorStatisticsProcessorFactory(vs) vsp, err := vspf.CreateValidatorStatisticsProcessor(peer.ArgValidatorStatisticsProcessor{}) @@ -41,7 +42,7 @@ func TestSovereignValidatorStatisticsProcessorFactory_CreateValidatorStatisticsP func TestSovereignValidatorStatisticsProcessorFactory_IsInterfaceNil(t *testing.T) { t.Parallel() - vs, _ := peer.NewValidatorStatisticsProcessorFactory() + vs := peer.NewValidatorStatisticsProcessorFactory() vspf, _ := peer.NewSovereignValidatorStatisticsProcessorFactory(vs) require.False(t, vspf.IsInterfaceNil()) } diff --git a/process/peer/validatorStatisticsProcessorFactory.go b/process/peer/validatorStatisticsProcessorFactory.go index db200a186a9..bd5436be7a2 100644 --- a/process/peer/validatorStatisticsProcessorFactory.go +++ b/process/peer/validatorStatisticsProcessorFactory.go @@ -6,8 +6,8 @@ type validatorStatisticsProcessorFactory struct { } // NewValidatorStatisticsProcessorFactory creates a new validator statistics processor factory for normal chain -func NewValidatorStatisticsProcessorFactory() (*validatorStatisticsProcessorFactory, error) { - return &validatorStatisticsProcessorFactory{}, nil +func NewValidatorStatisticsProcessorFactory() *validatorStatisticsProcessorFactory { + return &validatorStatisticsProcessorFactory{} } // CreateValidatorStatisticsProcessor creates a new validator statistics processor diff --git a/process/peer/validatorStatisticsProcessorFactory_test.go b/process/peer/validatorStatisticsProcessorFactory_test.go index 3e9d64510cb..8613830f193 100644 --- a/process/peer/validatorStatisticsProcessorFactory_test.go +++ b/process/peer/validatorStatisticsProcessorFactory_test.go @@ -3,16 +3,16 @@ package peer_test import ( "testing" + "github.com/stretchr/testify/require" + "github.com/multiversx/mx-chain-go/process" "github.com/multiversx/mx-chain-go/process/peer" - "github.com/stretchr/testify/require" ) func TestNewValidatorStatisticsProcessorFactory(t *testing.T) { t.Parallel() - vspf, err := peer.NewValidatorStatisticsProcessorFactory() - require.Nil(t, err) + vspf := peer.NewValidatorStatisticsProcessorFactory() require.NotNil(t, vspf) require.Implements(t, new(peer.ValidatorStatisticsProcessorCreator), vspf) } @@ -20,7 +20,7 @@ func TestNewValidatorStatisticsProcessorFactory(t *testing.T) { func TestValidatorStatisticsProcessorFactory_CreateValidatorStatisticsProcessor(t *testing.T) { t.Parallel() - vspf, _ := peer.NewValidatorStatisticsProcessorFactory() + vspf := peer.NewValidatorStatisticsProcessorFactory() vsp, err := vspf.CreateValidatorStatisticsProcessor(peer.ArgValidatorStatisticsProcessor{}) require.NotNil(t, err) @@ -35,6 +35,6 @@ func TestValidatorStatisticsProcessorFactory_CreateValidatorStatisticsProcessor( func TestValidatorStatisticsProcessorFactory_IsInterfaceNil(t *testing.T) { t.Parallel() - vspf, _ := peer.NewValidatorStatisticsProcessorFactory() + vspf := peer.NewValidatorStatisticsProcessorFactory() require.False(t, vspf.IsInterfaceNil()) } diff --git a/process/smartContract/hooks/blockChainHookFactory.go b/process/smartContract/hooks/blockChainHookFactory.go index 34855ad764f..1ddf7cd5817 100644 --- a/process/smartContract/hooks/blockChainHookFactory.go +++ b/process/smartContract/hooks/blockChainHookFactory.go @@ -7,8 +7,8 @@ type blockChainHookFactory struct { } // NewBlockChainHookFactory creates a new instance of blockChainHookFactory -func NewBlockChainHookFactory() (BlockChainHookHandlerCreator, error) { - return &blockChainHookFactory{}, nil +func NewBlockChainHookFactory() BlockChainHookHandlerCreator { + return &blockChainHookFactory{} } // CreateBlockChainHookHandler creates a blockchain hook based on the chain run type normal diff --git a/process/smartContract/hooks/blockChainHookFactory_test.go b/process/smartContract/hooks/blockChainHookFactory_test.go index f108bafd66a..eb5e26a9734 100644 --- a/process/smartContract/hooks/blockChainHookFactory_test.go +++ b/process/smartContract/hooks/blockChainHookFactory_test.go @@ -1,49 +1,44 @@ package hooks import ( + "fmt" "testing" + vmcommonBuiltInFunctions "github.com/multiversx/mx-chain-vm-common-go/builtInFunctions" + "github.com/stretchr/testify/require" + "github.com/multiversx/mx-chain-go/testscommon" "github.com/multiversx/mx-chain-go/testscommon/dataRetriever" "github.com/multiversx/mx-chain-go/testscommon/enableEpochsHandlerMock" "github.com/multiversx/mx-chain-go/testscommon/epochNotifier" "github.com/multiversx/mx-chain-go/testscommon/state" storageMock "github.com/multiversx/mx-chain-go/testscommon/storage" - vmcommonBuiltInFunctions "github.com/multiversx/mx-chain-vm-common-go/builtInFunctions" - "github.com/stretchr/testify/assert" ) func TestNewBlockChainHookFactory(t *testing.T) { t.Parallel() - factory, err := NewBlockChainHookFactory() - - assert.Nil(t, err) - assert.NotNil(t, factory) + factory := NewBlockChainHookFactory() + require.NotNil(t, factory) } func TestBlockChainHookFactory_CreateBlockChainHook(t *testing.T) { t.Parallel() - factory, err := NewBlockChainHookFactory() - - assert.Nil(t, err) - - _, err = factory.CreateBlockChainHookHandler(getDefaultArgs()) - - assert.Nil(t, err) + factory := NewBlockChainHookFactory() + blockChainHook, err := factory.CreateBlockChainHookHandler(getDefaultArgs()) + require.Equal(t, "*hooks.BlockChainHookImpl", fmt.Sprintf("%T", blockChainHook)) + require.Nil(t, err) } func TestBlockChainHookFactory_IsInterfaceNil(t *testing.T) { t.Parallel() - factory, err := NewBlockChainHookFactory() - - assert.Nil(t, err) - assert.False(t, factory.IsInterfaceNil()) + factory := NewBlockChainHookFactory() + require.False(t, factory.IsInterfaceNil()) factory = (*blockChainHookFactory)(nil) - assert.True(t, factory.IsInterfaceNil()) + require.True(t, factory.IsInterfaceNil()) } func getDefaultArgs() ArgBlockChainHook { diff --git a/process/smartContract/hooks/sovereignBlockChainHookFactory.go b/process/smartContract/hooks/sovereignBlockChainHookFactory.go index b122b5ef121..dd6e58bba9a 100644 --- a/process/smartContract/hooks/sovereignBlockChainHookFactory.go +++ b/process/smartContract/hooks/sovereignBlockChainHookFactory.go @@ -1,25 +1,16 @@ package hooks import ( - "github.com/multiversx/mx-chain-core-go/core/check" - - customErrors "github.com/multiversx/mx-chain-go/errors" "github.com/multiversx/mx-chain-go/process" ) // sovereignBlockChainHookFactory - factory for blockchain hook chain run type sovereign type sovereignBlockChainHookFactory struct { - blockChainHookFactory BlockChainHookHandlerCreator } // NewSovereignBlockChainHookFactory creates a new instance of sovereignBlockChainHookFactory -func NewSovereignBlockChainHookFactory(blockChainHookFactory BlockChainHookHandlerCreator) (BlockChainHookHandlerCreator, error) { - if check.IfNil(blockChainHookFactory) { - return nil, customErrors.ErrNilBlockChainHookFactory - } - return &sovereignBlockChainHookFactory{ - blockChainHookFactory: blockChainHookFactory, - }, nil +func NewSovereignBlockChainHookFactory() BlockChainHookHandlerCreator { + return &sovereignBlockChainHookFactory{} } // CreateBlockChainHookHandler creates a blockchain hook based on the chain run type sovereign diff --git a/process/smartContract/hooks/sovereignBlockChainHookFactory_test.go b/process/smartContract/hooks/sovereignBlockChainHookFactory_test.go index 9d8d5a9db64..be35c8a6a1a 100644 --- a/process/smartContract/hooks/sovereignBlockChainHookFactory_test.go +++ b/process/smartContract/hooks/sovereignBlockChainHookFactory_test.go @@ -1,52 +1,28 @@ package hooks import ( + "fmt" "testing" - "github.com/multiversx/mx-chain-go/errors" "github.com/stretchr/testify/require" ) func TestNewSovereignBlockChainHookFactory(t *testing.T) { t.Parallel() - factory, err := NewSovereignBlockChainHookFactory(nil) - - require.Nil(t, factory) - require.Equal(t, errors.ErrNilBlockChainHookFactory, err) - - baseFactory, _ := NewBlockChainHookFactory() - factory, err = NewSovereignBlockChainHookFactory(baseFactory) - - require.Nil(t, err) - require.NotNil(t, factory) + factory := NewSovereignBlockChainHookFactory() + require.False(t, factory.IsInterfaceNil()) } func TestSovereignBlockChainHookFactory_CreateBlockChainHook(t *testing.T) { t.Parallel() - baseFactory, _ := NewBlockChainHookFactory() - factory, _ := NewSovereignBlockChainHookFactory(baseFactory) - + factory := NewSovereignBlockChainHookFactory() bhh, err := factory.CreateBlockChainHookHandler(ArgBlockChainHook{}) - require.Nil(t, bhh) require.NotNil(t, err) bhh, err = factory.CreateBlockChainHookHandler(getDefaultArgs()) - require.Nil(t, err) - require.NotNil(t, bhh) -} - -func TestSovereignBlockChainHookFactory_IsInterfaceNil(t *testing.T) { - t.Parallel() - - baseFactory, _ := NewBlockChainHookFactory() - factory, _ := NewSovereignBlockChainHookFactory(baseFactory) - - require.False(t, factory.IsInterfaceNil()) - - factory = (*sovereignBlockChainHookFactory)(nil) - require.True(t, factory.IsInterfaceNil()) + require.Equal(t, "*hooks.sovereignBlockChainHook", fmt.Sprintf("%T", bhh)) } diff --git a/process/sync/shardForkDetectorFactory.go b/process/sync/shardForkDetectorFactory.go index c9af25bf631..b5a2d121ff5 100644 --- a/process/sync/shardForkDetectorFactory.go +++ b/process/sync/shardForkDetectorFactory.go @@ -6,8 +6,8 @@ type shardForkDetectorFactory struct { } // NewShardForkDetectorFactory creates a new shard fork detector factory -func NewShardForkDetectorFactory() (*shardForkDetectorFactory, error) { - return &shardForkDetectorFactory{}, nil +func NewShardForkDetectorFactory() *shardForkDetectorFactory { + return &shardForkDetectorFactory{} } // CreateForkDetector creates a new fork detector diff --git a/process/sync/shardForkDetectorFactory_test.go b/process/sync/shardForkDetectorFactory_test.go index af540e43829..c3e38404038 100644 --- a/process/sync/shardForkDetectorFactory_test.go +++ b/process/sync/shardForkDetectorFactory_test.go @@ -3,17 +3,17 @@ package sync_test import ( "testing" + "github.com/stretchr/testify/require" + "github.com/multiversx/mx-chain-go/process" "github.com/multiversx/mx-chain-go/process/sync" "github.com/multiversx/mx-chain-go/testscommon" - "github.com/stretchr/testify/require" ) func TestNewShardForkDetectorFactory(t *testing.T) { t.Parallel() - sfdf, err := sync.NewShardForkDetectorFactory() - require.Nil(t, err) + sfdf := sync.NewShardForkDetectorFactory() require.NotNil(t, sfdf) require.Implements(t, new(sync.ForkDetectorCreator), sfdf) } @@ -21,7 +21,7 @@ func TestNewShardForkDetectorFactory(t *testing.T) { func TestShardForkDetectorFactory_CreateForkDetector(t *testing.T) { t.Parallel() - sfdf, _ := sync.NewShardForkDetectorFactory() + sfdf := sync.NewShardForkDetectorFactory() args := sync.ForkDetectorFactoryArgs{ RoundHandler: &testscommon.RoundHandlerMock{}, HeaderBlackList: &testscommon.TimeCacheStub{}, @@ -38,6 +38,6 @@ func TestShardForkDetectorFactory_CreateForkDetector(t *testing.T) { func TestShardForkDetectorFactory_IsInterfaceNil(t *testing.T) { t.Parallel() - sfdf, _ := sync.NewShardForkDetectorFactory() + sfdf := sync.NewShardForkDetectorFactory() require.False(t, sfdf.IsInterfaceNil()) } diff --git a/process/sync/sovereignForkDetectorFactory_test.go b/process/sync/sovereignForkDetectorFactory_test.go index 81cc425ed0d..92b6a701caa 100644 --- a/process/sync/sovereignForkDetectorFactory_test.go +++ b/process/sync/sovereignForkDetectorFactory_test.go @@ -3,10 +3,11 @@ package sync_test import ( "testing" + "github.com/stretchr/testify/require" + "github.com/multiversx/mx-chain-go/process" "github.com/multiversx/mx-chain-go/process/sync" "github.com/multiversx/mx-chain-go/testscommon" - "github.com/stretchr/testify/require" ) func TestNewSovereignForkDetectorFactory(t *testing.T) { @@ -16,7 +17,7 @@ func TestNewSovereignForkDetectorFactory(t *testing.T) { require.Equal(t, process.ErrNilForkDetectorCreator, err) require.Nil(t, sfdf) - sf, _ := sync.NewShardForkDetectorFactory() + sf := sync.NewShardForkDetectorFactory() sfdf, err = sync.NewSovereignForkDetectorFactory(sf) require.Nil(t, err) require.NotNil(t, sfdf) @@ -26,7 +27,7 @@ func TestNewSovereignForkDetectorFactory(t *testing.T) { func TestSovereignForkDetectorFactory_CreateForkDetector(t *testing.T) { t.Parallel() - sf, _ := sync.NewShardForkDetectorFactory() + sf := sync.NewShardForkDetectorFactory() sfdf, _ := sync.NewSovereignForkDetectorFactory(sf) forkDetector, err := sfdf.CreateForkDetector(sync.ForkDetectorFactoryArgs{}) @@ -48,7 +49,7 @@ func TestSovereignForkDetectorFactory_CreateForkDetector(t *testing.T) { func TestSovereignForkDetectorFactory_IsInterfaceNil(t *testing.T) { t.Parallel() - sf, _ := sync.NewShardForkDetectorFactory() + sf := sync.NewShardForkDetectorFactory() sfdf, _ := sync.NewSovereignForkDetectorFactory(sf) require.False(t, sfdf.IsInterfaceNil()) } diff --git a/process/sync/storageBootstrap/shardBootstrapFactory.go b/process/sync/storageBootstrap/shardBootstrapFactory.go index 16025fd74de..6a27124f8c6 100644 --- a/process/sync/storageBootstrap/shardBootstrapFactory.go +++ b/process/sync/storageBootstrap/shardBootstrapFactory.go @@ -9,8 +9,8 @@ type shardBootstrapFactory struct { } // NewShardBootstrapFactory creates a new instance of shardBootstrapFactory for run type normal -func NewShardBootstrapFactory() (*shardBootstrapFactory, error) { - return &shardBootstrapFactory{}, nil +func NewShardBootstrapFactory() *shardBootstrapFactory { + return &shardBootstrapFactory{} } // CreateBootstrapper creates a new instance of shardBootstrapFactory for run type normal diff --git a/process/sync/storageBootstrap/shardBootstrapFactory_test.go b/process/sync/storageBootstrap/shardBootstrapFactory_test.go index c8fab3b8ee0..3ca6d984af2 100644 --- a/process/sync/storageBootstrap/shardBootstrapFactory_test.go +++ b/process/sync/storageBootstrap/shardBootstrapFactory_test.go @@ -4,6 +4,8 @@ import ( "testing" "time" + "github.com/stretchr/testify/require" + "github.com/multiversx/mx-chain-go/dataRetriever" "github.com/multiversx/mx-chain-go/process/mock" "github.com/multiversx/mx-chain-go/process/sync" @@ -17,43 +19,26 @@ import ( stateMock "github.com/multiversx/mx-chain-go/testscommon/state" statusHandlerMock "github.com/multiversx/mx-chain-go/testscommon/statusHandler" storageStubs "github.com/multiversx/mx-chain-go/testscommon/storage" - "github.com/stretchr/testify/require" ) func TestNewShardBootstrapFactory(t *testing.T) { t.Parallel() - sbf, err := NewShardBootstrapFactory() - + sbf := NewShardBootstrapFactory() require.NotNil(t, sbf) - require.Nil(t, err) + require.False(t, sbf.IsInterfaceNil()) } func TestShardBootstrapFactory_CreateShardBootstrapFactory(t *testing.T) { t.Parallel() - sbf, err := NewShardBootstrapFactory() - - require.NotNil(t, sbf) - require.Nil(t, err) - + sbf := NewShardBootstrapFactory() bootStrapper, err := sbf.CreateBootstrapper(getDefaultArgs()) require.NotNil(t, bootStrapper) require.Nil(t, err) } -func TestShardBootstrapFactory_IsInterfaceNil(t *testing.T) { - t.Parallel() - - sbf, _ := NewShardBootstrapFactory() - - require.False(t, sbf.IsInterfaceNil()) - - sbf = nil - require.True(t, sbf.IsInterfaceNil()) -} - func getDefaultArgs() sync.ArgShardBootstrapper { bootStorer := genericMocks.NewStorerMock() argBaseBoostrapper := sync.ArgBaseBootstrapper{ diff --git a/process/sync/storageBootstrap/sovereignShardBootstrapFactory.go b/process/sync/storageBootstrap/sovereignShardBootstrapFactory.go index 81d5b80c2c6..111e8111637 100644 --- a/process/sync/storageBootstrap/sovereignShardBootstrapFactory.go +++ b/process/sync/storageBootstrap/sovereignShardBootstrapFactory.go @@ -1,24 +1,16 @@ package storageBootstrap import ( - "github.com/multiversx/mx-chain-core-go/core/check" - "github.com/multiversx/mx-chain-go/errors" "github.com/multiversx/mx-chain-go/process" "github.com/multiversx/mx-chain-go/process/sync" ) type sovereignShardBootstrapFactory struct { - shardBootstrapFactory BootstrapperCreator } // NewSovereignShardBootstrapFactory creates a new instance of shardBootstrapFactory for run type sovereign -func NewSovereignShardBootstrapFactory(sbf BootstrapperCreator) (*sovereignShardBootstrapFactory, error) { - if check.IfNil(sbf) { - return nil, errors.ErrNilShardBootstrapFactory - } - return &sovereignShardBootstrapFactory{ - shardBootstrapFactory: sbf, - }, nil +func NewSovereignShardBootstrapFactory() *sovereignShardBootstrapFactory { + return &sovereignShardBootstrapFactory{} } // CreateBootstrapper creates a new instance of shardBootstrapFactory for run type sovereign diff --git a/process/sync/storageBootstrap/sovereignShardBootstrapFactory_test.go b/process/sync/storageBootstrap/sovereignShardBootstrapFactory_test.go index 4ad188d80f0..16cd5bad819 100644 --- a/process/sync/storageBootstrap/sovereignShardBootstrapFactory_test.go +++ b/process/sync/storageBootstrap/sovereignShardBootstrapFactory_test.go @@ -1,52 +1,29 @@ package storageBootstrap import ( + "fmt" "testing" - "github.com/multiversx/mx-chain-go/errors" - "github.com/multiversx/mx-chain-go/process/sync" "github.com/stretchr/testify/require" + + "github.com/multiversx/mx-chain-go/process/sync" ) func TestNewSovereignShardBootstrapFactory(t *testing.T) { t.Parallel() - ssbf, err := NewSovereignShardBootstrapFactory(nil) - - require.Nil(t, ssbf) - require.Equal(t, errors.ErrNilShardBootstrapFactory, err) - - sbf, _ := NewShardBootstrapFactory() - ssbf, err = NewSovereignShardBootstrapFactory(sbf) - - require.NotNil(t, ssbf) - require.Nil(t, err) + ssbf := NewSovereignShardBootstrapFactory() + require.False(t, ssbf.IsInterfaceNil()) } func TestSovereignShardBootstrapFactory_CreateShardBootstrapFactory(t *testing.T) { t.Parallel() - sbf, _ := NewShardBootstrapFactory() - ssbf, _ := NewSovereignShardBootstrapFactory(sbf) - + ssbf := NewSovereignShardBootstrapFactory() _, err := ssbf.CreateBootstrapper(sync.ArgShardBootstrapper{}) - require.NotNil(t, err) bootStrapper, err := ssbf.CreateBootstrapper(getDefaultArgs()) - - require.NotNil(t, bootStrapper) require.Nil(t, err) -} - -func TestSovereignShardBootstrapFactory_IsInterfaceNil(t *testing.T) { - t.Parallel() - - sbf, _ := NewShardBootstrapFactory() - ssbf, _ := NewSovereignShardBootstrapFactory(sbf) - - require.False(t, ssbf.IsInterfaceNil()) - - ssbf = nil - require.True(t, ssbf.IsInterfaceNil()) + require.Equal(t, "*sync.SovereignChainShardBootstrap", fmt.Sprintf("%T", bootStrapper)) } diff --git a/process/track/blockNotarizer.go b/process/track/blockNotarizer.go index 0d6b581fd6e..6520d3ff810 100644 --- a/process/track/blockNotarizer.go +++ b/process/track/blockNotarizer.go @@ -9,6 +9,7 @@ import ( "github.com/multiversx/mx-chain-core-go/data" "github.com/multiversx/mx-chain-core-go/hashing" "github.com/multiversx/mx-chain-core-go/marshal" + "github.com/multiversx/mx-chain-go/process" "github.com/multiversx/mx-chain-go/sharding" ) diff --git a/process/track/shardBlockTrackerFactory.go b/process/track/shardBlockTrackerFactory.go index 82c1a1bbe66..e823f3852cf 100644 --- a/process/track/shardBlockTrackerFactory.go +++ b/process/track/shardBlockTrackerFactory.go @@ -6,8 +6,8 @@ type shardBlockTrackerFactory struct { } // NewShardBlockTrackerFactory creates a new shard block tracker factory -func NewShardBlockTrackerFactory() (*shardBlockTrackerFactory, error) { - return &shardBlockTrackerFactory{}, nil +func NewShardBlockTrackerFactory() *shardBlockTrackerFactory { + return &shardBlockTrackerFactory{} } // CreateBlockTracker creates a new block tracker for shard chain diff --git a/process/track/shardBlockTrackerFactory_test.go b/process/track/shardBlockTrackerFactory_test.go index 494c21e7d06..29c4ce573c5 100644 --- a/process/track/shardBlockTrackerFactory_test.go +++ b/process/track/shardBlockTrackerFactory_test.go @@ -3,16 +3,16 @@ package track_test import ( "testing" + "github.com/stretchr/testify/require" + "github.com/multiversx/mx-chain-go/process" "github.com/multiversx/mx-chain-go/process/track" - "github.com/stretchr/testify/require" ) func TestNewShardBlockTrackerFactory(t *testing.T) { t.Parallel() - sbtcf, err := track.NewShardBlockTrackerFactory() - require.Nil(t, err) + sbtcf := track.NewShardBlockTrackerFactory() require.NotNil(t, sbtcf) require.Implements(t, new(track.BlockTrackerCreator), sbtcf) } @@ -20,7 +20,7 @@ func TestNewShardBlockTrackerFactory(t *testing.T) { func TestShardBlockTrackerFactory_CreateBlockTracker(t *testing.T) { t.Parallel() - sbtcf, _ := track.NewShardBlockTrackerFactory() + sbtcf := track.NewShardBlockTrackerFactory() bt, err := sbtcf.CreateBlockTracker(track.ArgShardTracker{}) require.NotNil(t, err) @@ -36,6 +36,6 @@ func TestShardBlockTrackerFactory_CreateBlockTracker(t *testing.T) { func TestShardBlockTrackerFactory_IsInterfaceNil(t *testing.T) { t.Parallel() - sbtcf, _ := track.NewShardBlockTrackerFactory() + sbtcf := track.NewShardBlockTrackerFactory() require.False(t, sbtcf.IsInterfaceNil()) } diff --git a/process/track/sovereignBlockTrackerFactory_test.go b/process/track/sovereignBlockTrackerFactory_test.go index 12cab7bae10..0bd158bc273 100644 --- a/process/track/sovereignBlockTrackerFactory_test.go +++ b/process/track/sovereignBlockTrackerFactory_test.go @@ -3,10 +3,11 @@ package track_test import ( "testing" + "github.com/stretchr/testify/require" + "github.com/multiversx/mx-chain-go/process" "github.com/multiversx/mx-chain-go/process/track" "github.com/multiversx/mx-chain-go/testscommon" - "github.com/stretchr/testify/require" ) func TestNewSovereignBlockTrackerFactory(t *testing.T) { @@ -16,7 +17,7 @@ func TestNewSovereignBlockTrackerFactory(t *testing.T) { require.NotNil(t, err) require.Nil(t, sbtcf) - sf, _ := track.NewShardBlockTrackerFactory() + sf := track.NewShardBlockTrackerFactory() sbtcf, err = track.NewSovereignBlockTrackerFactory(sf) require.Nil(t, err) require.NotNil(t, sbtcf) @@ -26,7 +27,7 @@ func TestNewSovereignBlockTrackerFactory(t *testing.T) { func TestSovereignBlockTrackerFactory_CreateBlockTracker(t *testing.T) { t.Parallel() - sf, _ := track.NewShardBlockTrackerFactory() + sf := track.NewShardBlockTrackerFactory() sbtcf, _ := track.NewSovereignBlockTrackerFactory(sf) bt, err := sbtcf.CreateBlockTracker(track.ArgShardTracker{}) @@ -44,7 +45,7 @@ func TestSovereignBlockTrackerFactory_CreateBlockTracker(t *testing.T) { func TestSovereignBlockTrackerFactory_IsInterfaceNil(t *testing.T) { t.Parallel() - sf, _ := track.NewShardBlockTrackerFactory() + sf := track.NewShardBlockTrackerFactory() sbtcf, _ := track.NewSovereignBlockTrackerFactory(sf) require.False(t, sbtcf.IsInterfaceNil()) diff --git a/storage/factory/shardAdditionalStorageServiceFactory.go b/storage/factory/shardAdditionalStorageServiceFactory.go index 5efd37ce581..e96449df54d 100644 --- a/storage/factory/shardAdditionalStorageServiceFactory.go +++ b/storage/factory/shardAdditionalStorageServiceFactory.go @@ -6,8 +6,8 @@ type shardAdditionalStorageServiceFactory struct { } // NewShardAdditionalStorageServiceFactory creates a new instance of shardAdditionalStorageServiceFactory -func NewShardAdditionalStorageServiceFactory() (*shardAdditionalStorageServiceFactory, error) { - return &shardAdditionalStorageServiceFactory{}, nil +func NewShardAdditionalStorageServiceFactory() *shardAdditionalStorageServiceFactory { + return &shardAdditionalStorageServiceFactory{} } // CreateAdditionalStorageUnits does nothing diff --git a/storage/factory/shardAdditionalStorageServiceFactory_test.go b/storage/factory/shardAdditionalStorageServiceFactory_test.go index 6a22a2a24f3..5306ed39432 100644 --- a/storage/factory/shardAdditionalStorageServiceFactory_test.go +++ b/storage/factory/shardAdditionalStorageServiceFactory_test.go @@ -3,29 +3,22 @@ package factory_test import ( "testing" - "github.com/multiversx/mx-chain-go/storage/factory" "github.com/stretchr/testify/require" + + "github.com/multiversx/mx-chain-go/storage/factory" ) func TestNewShardAdditionalStorageServiceFactory(t *testing.T) { t.Parallel() - f, err := factory.NewShardAdditionalStorageServiceFactory() - require.NotNil(t, f) - require.NoError(t, err) + f := factory.NewShardAdditionalStorageServiceFactory() + require.False(t, f.IsInterfaceNil()) } func TestShardAdditionalStorageServiceFactory_CreateAdditionalStorageUnits(t *testing.T) { t.Parallel() - f, _ := factory.NewShardAdditionalStorageServiceFactory() + f := factory.NewShardAdditionalStorageServiceFactory() err := f.CreateAdditionalStorageUnits(nil, nil, "") require.NoError(t, err) } - -func TestShardAdditionalStorageServiceFactory_IsInterfaceNil(t *testing.T) { - t.Parallel() - - f, _ := factory.NewShardAdditionalStorageServiceFactory() - require.False(t, f.IsInterfaceNil()) -} diff --git a/testscommon/components/components.go b/testscommon/components/components.go index d1dd94b9787..eb5561d70ee 100644 --- a/testscommon/components/components.go +++ b/testscommon/components/components.go @@ -1254,7 +1254,6 @@ func GetRunTypeComponents() factory.RunTypeComponentsHolder { // GetRunTypeComponentsWithCoreComp - func GetRunTypeComponentsWithCoreComp(coreComponents factory.CoreComponentsHolder) factory.RunTypeComponentsHolder { - generalCfg := GetGeneralConfig() args := runType.ArgsRunTypeComponents{ CoreComponents: coreComponents, CryptoComponents: &mockCoreComp.CryptoComponentsStub{ @@ -1267,7 +1266,21 @@ func GetRunTypeComponentsWithCoreComp(coreComponents factory.CoreComponentsHolde GenesisMintingSenderAddress: "erd17rc0pu8s7rc0pu8s7rc0pu8s7rc0pu8s7rc0pu8s7rc0pu8s7rcqqkhty3", }, }, - GeneralConfig: &generalCfg, + GeneralConfig: &config.Config{ + Versions: config.VersionsConfig{ + VersionsByEpochs: []config.VersionByEpochs{ + { + Version: "*", + }, + }, + Cache: config.CacheConfig{ + Type: "LRU", + Capacity: 10000, + Shards: 1, + }, + DefaultVersion: "*", + }, + }, }, InitialAccounts: createAccounts(), } diff --git a/testscommon/factory/headerValidatorFactoryMock.go b/testscommon/factory/headerValidatorFactoryMock.go index 11fae039778..3bfb114035c 100644 --- a/testscommon/factory/headerValidatorFactoryMock.go +++ b/testscommon/factory/headerValidatorFactoryMock.go @@ -1,6 +1,7 @@ package factory import ( + "github.com/multiversx/mx-chain-go/node/mock" "github.com/multiversx/mx-chain-go/process" processBlock "github.com/multiversx/mx-chain-go/process/block" ) @@ -15,7 +16,7 @@ func (h *HeaderValidatorFactoryMock) CreateHeaderValidator(args processBlock.Arg if h.CreateHeaderValidatorCalled != nil { return h.CreateHeaderValidatorCalled(args) } - return nil, nil + return &mock.HeaderValidatorStub{}, nil } // IsInterfaceNil - diff --git a/testscommon/genesisMocks/runTypeComponentsStub.go b/testscommon/genesisMocks/runTypeComponentsStub.go index 4f975255c6b..b90aad4c87c 100644 --- a/testscommon/genesisMocks/runTypeComponentsStub.go +++ b/testscommon/genesisMocks/runTypeComponentsStub.go @@ -45,30 +45,25 @@ type RunTypeComponentsStub struct { // NewRunTypeComponentsStub - func NewRunTypeComponentsStub() *RunTypeComponentsStub { - blockChainHookHandlerFactory, _ := hooks.NewBlockChainHookFactory() - transactionCoordinatorFactory, _ := coordinator.NewShardTransactionCoordinatorFactory() - scResultsPreProcessorCreator, _ := preprocess.NewSmartContractResultPreProcessorFactory() - scProcessorCreator := processProxy.NewSCProcessProxyFactory() accountsCreator, _ := factory.NewAccountCreator(factory.ArgsAccountCreator{ Hasher: &hashingMocks.HasherMock{}, Marshaller: &marshallerMock.MarshalizerMock{}, EnableEpochsHandler: &enableEpochsHandlerMock.EnableEpochsHandlerStub{}, }) - vmContainerShard := factoryVm.NewVmContainerShardFactory() vmContainerMeta, _ := factoryVm.NewVmContainerMetaFactory(systemSmartContracts.NewVMContextCreator()) hdrFactory, _ := block.NewShardHeaderFactory(createHeaderVersionHandler("*")) return &RunTypeComponentsStub{ - BlockChainHookHandlerFactory: blockChainHookHandlerFactory, - TransactionCoordinatorFactory: transactionCoordinatorFactory, - SCResultsPreProcessorFactory: scResultsPreProcessorCreator, - SCProcessorFactory: scProcessorCreator, + BlockChainHookHandlerFactory: hooks.NewBlockChainHookFactory(), + TransactionCoordinatorFactory: coordinator.NewShardTransactionCoordinatorFactory(), + SCResultsPreProcessorFactory: preprocess.NewSmartContractResultPreProcessorFactory(), + SCProcessorFactory: processProxy.NewSCProcessProxyFactory(), AccountParser: &AccountsParserStub{}, AccountCreator: accountsCreator, VMContextCreatorHandler: systemSmartContracts.NewVMContextCreator(), ShardCoordinatorFactory: sharding.NewMultiShardCoordinatorFactory(), TxPreProcessorFactory: preprocess.NewTxPreProcessorCreator(), - VmContainerShardFactory: vmContainerShard, + VmContainerShardFactory: factoryVm.NewVmContainerShardFactory(), VmContainerMetaFactory: vmContainerMeta, PreProcessorsContainerFactoryCreatorField: shard.NewPreProcessorContainerFactoryCreator(), VersionedHeaderFactoryField: hdrFactory, @@ -78,8 +73,6 @@ func NewRunTypeComponentsStub() *RunTypeComponentsStub { // NewSovereignRunTypeComponentsStub - func NewSovereignRunTypeComponentsStub() *RunTypeComponentsStub { runTypeComponents := NewRunTypeComponentsStub() - - blockChainHookHandlerFactory, _ := hooks.NewSovereignBlockChainHookFactory(runTypeComponents.BlockChainHookHandlerFactory) transactionCoordinatorFactory, _ := coordinator.NewSovereignTransactionCoordinatorFactory(runTypeComponents.TransactionCoordinatorFactory) scResultsPreProcessorCreator, _ := preprocess.NewSovereignSmartContractResultPreProcessorFactory(runTypeComponents.SCResultsPreProcessorFactory) scProcessorCreator, _ := processorV2.NewSovereignSCProcessFactory(runTypeComponents.SCProcessorFactory) @@ -99,7 +92,7 @@ func NewSovereignRunTypeComponentsStub() *RunTypeComponentsStub { sovHdrFactory, _ := block.NewSovereignShardHeaderFactory(createHeaderVersionHandler("S1")) return &RunTypeComponentsStub{ - BlockChainHookHandlerFactory: blockChainHookHandlerFactory, + BlockChainHookHandlerFactory: hooks.NewSovereignBlockChainHookFactory(), TransactionCoordinatorFactory: transactionCoordinatorFactory, SCResultsPreProcessorFactory: scResultsPreProcessorCreator, SCProcessorFactory: scProcessorCreator, diff --git a/testscommon/processMocks/runTypeComponentsStub.go b/testscommon/processMocks/runTypeComponentsStub.go index 44e47cfe420..64bcfde28a4 100644 --- a/testscommon/processMocks/runTypeComponentsStub.go +++ b/testscommon/processMocks/runTypeComponentsStub.go @@ -12,9 +12,8 @@ type RunTypeComponentsStub struct { // NewRunTypeComponentsStub - func NewRunTypeComponentsStub() *RunTypeComponentsStub { - scrPreProcFactory, _ := preprocess.NewSmartContractResultPreProcessorFactory() return &RunTypeComponentsStub{ - SCResultsPreProcessorFactory: scrPreProcFactory, + SCResultsPreProcessorFactory: preprocess.NewSmartContractResultPreProcessorFactory(), TxPreProcessorFactory: preprocess.NewTxPreProcessorCreator(), } }