New CLI flag: --handle-contracts. Minor refactoring.

cmd/rosetta/cli.go

@@ -156,11 +156,22 @@ VERSION:
 		Required: true,
 	}
 
+	cliFlagShouldHandleContracts = cli.BoolFlag{
+		Name:  "handle-contracts",
+		Usage: "Whether to handle balance changes of smart contracts or not.",
+	}
+
 	cliFlagConfigFileCustomCurrencies = cli.StringFlag{
 		Name:     "config-custom-currencies",
 		Usage:    "Specifies the configuration file for custom currencies.",
 		Required: false,
 	}
+
+	cliFlagConfigFileNodeFeatures = cli.StringFlag{
+		Name:     "config-node-features",
+		Usage:    "Specifies the configuration file for features activation on Node's side.",
+		Required: false,
+	}
 )
 
 func getAllCliFlags() []cli.Flag {
@@ -187,7 +198,9 @@ func getAllCliFlags() []cli.Flag {
 		cliFlagNativeCurrencySymbol,
 		cliFlagFirstHistoricalEpoch,
 		cliFlagNumHistoricalEpochs,
+		cliFlagShouldHandleContracts,
 		cliFlagConfigFileCustomCurrencies,
+		cliFlagConfigFileNodeFeatures,
 	}
 }
 
@@ -215,7 +228,9 @@ type parsedCliFlags struct {
 	nativeCurrencySymbol        string
 	firstHistoricalEpoch        uint32
 	numHistoricalEpochs         uint32
+	shouldHandleContracts       bool
 	configFileCustomCurrencies  string
+	configFileNodeFeatures      string
 }
 
 func getParsedCliFlags(ctx *cli.Context) parsedCliFlags {
@@ -243,6 +258,8 @@ func getParsedCliFlags(ctx *cli.Context) parsedCliFlags {
 		nativeCurrencySymbol:        ctx.GlobalString(cliFlagNativeCurrencySymbol.Name),
 		firstHistoricalEpoch:        uint32(ctx.GlobalUint(cliFlagFirstHistoricalEpoch.Name)),
 		numHistoricalEpochs:         uint32(ctx.GlobalUint(cliFlagNumHistoricalEpochs.Name)),
+		shouldHandleContracts:       ctx.GlobalBool(cliFlagShouldHandleContracts.Name),
 		configFileCustomCurrencies:  ctx.GlobalString(cliFlagConfigFileCustomCurrencies.Name),
+		configFileNodeFeatures:      ctx.GlobalString(cliFlagConfigFileNodeFeatures.Name),
 	}
 }

cmd/rosetta/main.go

@@ -81,6 +81,7 @@ func startRosetta(ctx *cli.Context) error {
 		GenesisBlockHash:            cliFlags.genesisBlock,
 		FirstHistoricalEpoch:        cliFlags.firstHistoricalEpoch,
 		NumHistoricalEpochs:         cliFlags.numHistoricalEpochs,
+		ShouldHandleContracts:       cliFlags.shouldHandleContracts,
 	})
 	if err != nil {
 		return err

server/factory/provider.go

@@ -48,6 +48,7 @@ type ArgsCreateNetworkProvider struct {
 	GenesisTimestamp            int64
 	FirstHistoricalEpoch        uint32
 	NumHistoricalEpochs         uint32
+	ShouldHandleContracts       bool
 }
 
 // CreateNetworkProvider creates a network provider
@@ -138,6 +139,7 @@ func CreateNetworkProvider(args ArgsCreateNetworkProvider) (NetworkProvider, err
 		GenesisTimestamp:            args.GenesisTimestamp,
 		FirstHistoricalEpoch:        args.FirstHistoricalEpoch,
 		NumHistoricalEpochs:         args.NumHistoricalEpochs,
+		ShouldHandleContracts:       args.ShouldHandleContracts,
 
 		ObserverFacade: &components.ObserverFacade{
 			Processor:            baseProcessor,

server/provider/networkProvider.go

@@ -41,6 +41,7 @@ type ArgsNewNetworkProvider struct {
 	GenesisTimestamp            int64
 	FirstHistoricalEpoch        uint32
 	NumHistoricalEpochs         uint32
+	ShouldHandleContracts       bool
 
 	ObserverFacade observerFacade
 
@@ -62,6 +63,7 @@ type networkProvider struct {
 	genesisTimestamp            int64
 	firstHistoricalEpoch        uint32
 	numHistoricalEpochs         uint32
+	shouldHandleContracts       bool
 
 	observerFacade observerFacade
 
@@ -101,6 +103,7 @@ func NewNetworkProvider(args ArgsNewNetworkProvider) (*networkProvider, error) {
 		genesisTimestamp:            args.GenesisTimestamp,
 		firstHistoricalEpoch:        args.FirstHistoricalEpoch,
 		numHistoricalEpochs:         args.NumHistoricalEpochs,
+		shouldHandleContracts:       args.ShouldHandleContracts,
 
 		observerFacade: args.ObserverFacade,
 
@@ -312,14 +315,15 @@ func (provider *networkProvider) IsAddressObserved(address string) (bool, error)
 	}
 
 	shard := provider.observerFacade.ComputeShardId(pubKey)
-	isObservedActualShard := shard == provider.observedActualShard
-	isObservedProjectedShard := pubKey[len(pubKey)-1] == byte(provider.observedProjectedShard)
 
-	if provider.observedProjectedShardIsSet {
-		return isObservedProjectedShard, nil
-	}
+	noConstraintAboutProjectedShard := !provider.observedProjectedShardIsSet
+	noConstraintAboutHandlingContracts := provider.shouldHandleContracts
+
+	passesConstraintAboutObservedActualShard := shard == provider.observedActualShard
+	passesConstraintAboutObservedProjectedShard := noConstraintAboutProjectedShard || pubKey[len(pubKey)-1] == byte(provider.observedProjectedShard)
+	passesConstraintAboutHandlingContracts := noConstraintAboutHandlingContracts || !core.IsSmartContractAddress(pubKey)
 
-	return isObservedActualShard, nil
+	return passesConstraintAboutObservedActualShard && passesConstraintAboutObservedProjectedShard && passesConstraintAboutHandlingContracts, nil
 }
 
 // ComputeShardIdOfPubKey computes the shard ID of a public key

server/provider/networkProvider_test.go

@@ -39,6 +39,7 @@ func TestNewNetworkProvider(t *testing.T) {
 		GenesisTimestamp:      123456789,
 		FirstHistoricalEpoch:  1000,
 		NumHistoricalEpochs:   1024,
+		ShouldHandleContracts: true,
 		ObserverFacade:        testscommon.NewObserverFacadeMock(),
 		Hasher:                testscommon.RealWorldBlake2bHasher,
 		MarshalizerForHashing: testscommon.MarshalizerForHashing,
@@ -71,6 +72,7 @@ func TestNewNetworkProvider(t *testing.T) {
 	assert.Equal(t, int64(123456789), provider.GetGenesisTimestamp())
 	assert.Equal(t, uint32(1000), provider.firstHistoricalEpoch)
 	assert.Equal(t, uint32(1024), provider.numHistoricalEpochs)
+	assert.Equal(t, true, provider.shouldHandleContracts)
 }
 
 func TestNetworkProvider_DoGetBlockByNonce(t *testing.T) {
@@ -236,6 +238,98 @@ func Test_ComputeTransactionFeeForMoveBalance(t *testing.T) {
 	})
 }
 
+func TestNetworkProvider_IsAddressObserved(t *testing.T) {
+	t.Run("no projected shard, do not handle contracts", func(t *testing.T) {
+		args := createDefaultArgsNewNetworkProvider()
+		args.ObservedActualShard = 0
+		args.ShouldHandleContracts = false
+
+		provider, err := NewNetworkProvider(args)
+		require.Nil(t, err)
+		require.NotNil(t, provider)
+
+		isObserved, err := provider.IsAddressObserved("erd1qyu5wthldzr8wx5c9ucg8kjagg0jfs53s8nr3zpz3hypefsdd8ssycr6th")
+		require.NoError(t, err)
+		require.False(t, isObserved)
+
+		isObserved, err = provider.IsAddressObserved("erd1spyavw0956vq68xj8y4tenjpq2wd5a9p2c6j8gsz7ztyrnpxrruqzu66jx")
+		require.NoError(t, err)
+		require.True(t, isObserved)
+
+		isObserved, err = provider.IsAddressObserved("erd1k2s324ww2g0yj38qn2ch2jwctdy8mnfxep94q9arncc6xecg3xaq6mjse8")
+		require.NoError(t, err)
+		require.False(t, isObserved)
+
+		isObserved, err = provider.IsAddressObserved("erd1qqqqqqqqqqqqqpgqws44xjx2t056nn79fn29q0rjwfrd3m43396ql35kxy")
+		require.NoError(t, err)
+		require.False(t, isObserved)
+	})
+
+	t.Run("with projected shard, do not handle contracts", func(t *testing.T) {
+		args := createDefaultArgsNewNetworkProvider()
+		args.ObservedActualShard = 0
+		args.ObservedProjectedShard = 0
+		args.ObservedProjectedShardIsSet = true
+		args.ShouldHandleContracts = false
+
+		provider, err := NewNetworkProvider(args)
+		require.Nil(t, err)
+		require.NotNil(t, provider)
+
+		isObserved, err := provider.IsAddressObserved("erd1ldjsdetjvegjdnda0qw2h62kq6rpvrklkc5pw9zxm0nwulfhtyqqtyc4vq")
+		require.NoError(t, err)
+		require.True(t, isObserved)
+
+		isObserved, err = provider.IsAddressObserved("erd1spyavw0956vq68xj8y4tenjpq2wd5a9p2c6j8gsz7ztyrnpxrruqzu66jx")
+		require.NoError(t, err)
+		require.False(t, isObserved)
+
+		isObserved, err = provider.IsAddressObserved("erd1qqqqqqqqqqqqqpgqws44xjx2t056nn79fn29q0rjwfrd3m43396ql35kxy")
+		require.NoError(t, err)
+		require.False(t, isObserved)
+	})
+
+	t.Run("no projected shard, handle contracts", func(t *testing.T) {
+		args := createDefaultArgsNewNetworkProvider()
+		args.ObservedActualShard = 0
+		args.ShouldHandleContracts = true
+
+		provider, err := NewNetworkProvider(args)
+		require.Nil(t, err)
+		require.NotNil(t, provider)
+
+		isObserved, err := provider.IsAddressObserved("erd1qyu5wthldzr8wx5c9ucg8kjagg0jfs53s8nr3zpz3hypefsdd8ssycr6th")
+		require.NoError(t, err)
+		require.False(t, isObserved)
+
+		isObserved, err = provider.IsAddressObserved("erd1spyavw0956vq68xj8y4tenjpq2wd5a9p2c6j8gsz7ztyrnpxrruqzu66jx")
+		require.NoError(t, err)
+		require.True(t, isObserved)
+
+		isObserved, err = provider.IsAddressObserved("erd1k2s324ww2g0yj38qn2ch2jwctdy8mnfxep94q9arncc6xecg3xaq6mjse8")
+		require.NoError(t, err)
+		require.False(t, isObserved)
+
+		isObserved, err = provider.IsAddressObserved("erd1qqqqqqqqqqqqqpgqws44xjx2t056nn79fn29q0rjwfrd3m43396ql35kxy")
+		require.NoError(t, err)
+		require.True(t, isObserved)
+	})
+
+	t.Run("with error", func(t *testing.T) {
+		args := createDefaultArgsNewNetworkProvider()
+		args.ObservedActualShard = 0
+		args.ShouldHandleContracts = true
+
+		provider, err := NewNetworkProvider(args)
+		require.Nil(t, err)
+		require.NotNil(t, provider)
+
+		isObserved, err := provider.IsAddressObserved("erd1test")
+		require.Error(t, err)
+		require.False(t, isObserved)
+	})
+}
+
 func createDefaultArgsNewNetworkProvider() ArgsNewNetworkProvider {
 	return ArgsNewNetworkProvider{
 		IsOffline:                   false,

server/services/blockService.go

@@ -145,7 +145,7 @@ func (service *blockService) createGenesisOperations(balances []*resources.Genes
 		operations = append(operations, operation)
 	}
 
-	operations, err := filterOperationsByAddress(operations, service.extension.isAddressObserved)
+	operations, err := filterOperationsByAddress(operations, service.provider.IsAddressObserved)
 	if err != nil {
 		return nil, err
 	}

server/services/networkProviderExtension.go

@@ -70,22 +70,16 @@ func (extension *networkProviderExtension) getGenesisBlockIdentifier() *types.Bl
 	return blockSummaryToIdentifier(summary)
 }
 
-func (extension *networkProviderExtension) isAddressObserved(address string) (bool, error) {
-	belongsToObservedShard, err := extension.provider.IsAddressObserved(address)
-	if err != nil {
-		return false, err
-	}
-
-	isUserAddress := extension.isUserAddress(address)
-	return belongsToObservedShard && isUserAddress, nil
-}
-
 func (extension *networkProviderExtension) isUserAddress(address string) bool {
-	pubkey, err := extension.provider.ConvertAddressToPubKey(address)
+	pubKey, err := extension.provider.ConvertAddressToPubKey(address)
 	if err != nil {
 		// E.g., when address = "metachain"
 		return false
 	}
 
-	return !core.IsSmartContractAddress(pubkey)
+	return extension.isUserPubKey(pubKey)
+}
+
+func (extension *networkProviderExtension) isUserPubKey(pubKey []byte) bool {
+	return !core.IsSmartContractAddress(pubKey)
 }

server/services/transactionsTransformer.go

@@ -66,7 +66,7 @@ func (transformer *transactionsTransformer) transformBlockTxs(block *api.Block)
 	}
 
 	for _, rosettaTx := range rosettaTxs {
-		filteredOperations, err := filterOperationsByAddress(rosettaTx.Operations, transformer.extension.isAddressObserved)
+		filteredOperations, err := filterOperationsByAddress(rosettaTx.Operations, transformer.provider.IsAddressObserved)
 		if err != nil {
 			return nil, err
 		}

systemtests/proxyToObserverAdapter.go

@@ -57,7 +57,8 @@ func startAdapter(ctx *cli.Context) error {
 		sleepDuration: ctx.GlobalUint(cliFlagSleep.Name),
 	}
 
-	router := gin.Default()
+	router := gin.New()
+	router.Use(gin.Recovery())
 	router.GET("/node/status", adapter.getNodeStatus)
 	router.GET("/node/epoch-start/:epoch", adapter.getEpochStart)
 	router.GET("/block/by-nonce/:nonce", adapter.getBlockByNonce)