Update config and file namings

.github/assets.config.yaml

@@ -5,7 +5,7 @@ client_urls:
   binance:
     dex: "https://dex.binance.org"
     explorer: "https://explorer.binance.org"
-  assets_manager_api: "https://assets-manager-api.herokuapp.com"
+  assets_manager_api: "https://api.assets.trustwallet.com"
 
 urls:
   assets_app: "https://assets.trustwalletapp.com"

internal/manager/commands.go

@@ -1,159 +1,113 @@
 package manager
 
 import (
-	"os"
+	"encoding/json"
+	"fmt"
+	"time"
 
+	log "github.com/sirupsen/logrus"
+
+	libFile "github.com/trustwallet/assets-go-libs/file"
 	"github.com/trustwallet/assets-go-libs/path"
+	"github.com/trustwallet/assets-go-libs/validation/info"
+	"github.com/trustwallet/assets-go-libs/validation/tokenlist"
 	"github.com/trustwallet/assets/internal/config"
-	"github.com/trustwallet/assets/internal/file"
-	"github.com/trustwallet/assets/internal/processor"
-	"github.com/trustwallet/assets/internal/report"
-	"github.com/trustwallet/assets/internal/service"
-
-	log "github.com/sirupsen/logrus"
-	"github.com/spf13/cobra"
+	"github.com/trustwallet/go-primitives/asset"
+	"github.com/trustwallet/go-primitives/coin"
 )
 
-var configPath, root string
-
-func InitCommands() {
-	rootCmd.Flags().StringVar(&configPath, "config", ".github/assets.config.yaml",
-		"config file (default is $HOME/.github/assets.config.yaml)")
-	rootCmd.Flags().StringVar(&root, "root", ".", "root path to files")
-
-	rootCmd.AddCommand(checkCmd)
-	rootCmd.AddCommand(fixCmd)
-	rootCmd.AddCommand(updateAutoCmd)
-	rootCmd.AddCommand(addTokenCmd)
-	rootCmd.AddCommand(addTokenlistCmd)
-	rootCmd.AddCommand(addTokenlistExtendedCmd)
-}
-
-var (
-	rootCmd = &cobra.Command{
-		Use:   "assets",
-		Short: "",
-		Long:  "",
-		Run:   func(cmd *cobra.Command, args []string) {},
-	}
-	checkCmd = &cobra.Command{
-		Use:   "check",
-		Short: " Execute validation checks",
-		Run: func(cmd *cobra.Command, args []string) {
-			assetsService := InitAssetsService()
-			assetsService.RunJob(assetsService.Check)
-		},
-	}
-	fixCmd = &cobra.Command{
-		Use:   "fix",
-		Short: "Perform automatic fixes where possible",
-		Run: func(cmd *cobra.Command, args []string) {
-			assetsService := InitAssetsService()
-			assetsService.RunJob(assetsService.Fix)
-		},
-	}
-	updateAutoCmd = &cobra.Command{
-		Use:   "update-auto",
-		Short: "Run automatic updates from external sources",
-		Run: func(cmd *cobra.Command, args []string) {
-			assetsService := InitAssetsService()
-			assetsService.RunUpdateAuto()
-		},
+func CreateAssetInfoJSONTemplate(token string) error {
+	c, tokenID, err := asset.ParseID(token)
+	if err != nil {
+		return fmt.Errorf("failed to parse token id: %v", err)
 	}
 
-	addTokenCmd = &cobra.Command{
-		Use:   "add-token",
-		Short: "Creates info.json template for the asset",
-		Run: func(cmd *cobra.Command, args []string) {
-			if len(args) != 1 {
-				log.Fatal("1 argument was expected")
-			}
-
-			err := CreateAssetInfoJSONTemplate(args[0])
-			if err != nil {
-				log.Fatalf("Can't create asset info json template: %v", err)
-			}
-		},
+	chain, ok := coin.Coins[c]
+	if !ok {
+		return fmt.Errorf("invalid token")
 	}
 
-	addTokenlistCmd = &cobra.Command{
-		Use:   "add-tokenlist",
-		Short: "Adds token to tokenlist.json",
-		Run: func(cmd *cobra.Command, args []string) {
-			if len(args) != 1 {
-				log.Fatal("1 argument was expected")
-			}
-
-			tokenID, chain, err := GetChainAndTokenID(args[0])
-			if err != nil {
-				log.Fatalf("Can't get chain and tokenID: %v", err)
-			}
-
-			tokenListPath := path.GetTokenListPath(chain.Handle)
-
-			err = AddTokenToTokenListJSON(args[0], tokenID, tokenListPath, chain)
-			if err != nil {
-				log.Fatalf("Can't add token to tokenlist-extended.json: %v", err)
-			}
+	assetInfoPath := path.GetAssetInfoPath(chain.Handle, tokenID)
+
+	var emptyStr string
+	var emptyInt int
+	assetInfoModel := info.AssetModel{
+		Name:     &emptyStr,
+		Type:     &emptyStr,
+		Symbol:   &emptyStr,
+		Decimals: &emptyInt,
+		Website:  &emptyStr,
+		Explorer: &emptyStr,
+		Status:   &emptyStr,
+		ID:       &tokenID,
+		Links: []info.Link{
+			{
+				Name: &emptyStr,
+				URL:  &emptyStr,
+			},
 		},
+		Tags: []string{""},
 	}
 
-	addTokenlistExtendedCmd = &cobra.Command{
-		Use:   "add-tokenlist-extended",
-		Short: "Adds token to tokenlist-extended.json",
-		Run: func(cmd *cobra.Command, args []string) {
-			if len(args) != 1 {
-				log.Fatal("1 argument was expected")
-			}
-
-			tokenID, chain, err := GetChainAndTokenID(args[0])
-			if err != nil {
-				log.Fatalf("Can't get chain and tokenID: %v", err)
-			}
-
-			tokenListExtendedPath := path.GetTokenListExtendedPath(chain.Handle)
-
-			err = AddTokenToTokenListJSON(args[0], tokenID, tokenListExtendedPath, chain)
-			if err != nil {
-				log.Fatalf("Can't add token to tokenlist-extended.json: %v", err)
-			}
-		},
+	bytes, err := json.Marshal(&assetInfoModel)
+	if err != nil {
+		return fmt.Errorf("failed to marshal json: %v", err)
 	}
-)
 
-func InitAssetsService() *service.Service {
-	setup()
+	f, err := libFile.CreateFileWithPath(assetInfoPath)
+	if err != nil {
+		return fmt.Errorf("failed to create file: %v", err)
+	}
+	defer f.Close()
 
-	paths, err := file.ReadLocalFileStructure(root, config.Default.ValidatorsSettings.RootFolder.SkipFiles)
+	_, err = f.Write(bytes)
 	if err != nil {
-		log.WithError(err).Fatal("Failed to load file structure.")
+		return fmt.Errorf("failed to write bytes to file")
 	}
 
-	fileService := file.NewService(paths...)
-	validatorsService := processor.NewService(fileService)
-	reportService := report.NewService()
+	err = libFile.FormatJSONFile(assetInfoPath)
+	if err != nil {
+		return fmt.Errorf("failed to format json file")
+	}
 
-	return service.NewService(fileService, validatorsService, reportService, paths)
+	return nil
 }
 
-func setup() {
-	if err := config.SetConfig(configPath); err != nil {
-		log.WithError(err).Fatal("Failed to set config.")
-	}
+func AddTokenToTokenListJSON(token, tokenID, tokenListPath string, chain coin.Coin) error {
+	setup()
 
-	logLevel, err := log.ParseLevel(config.Default.App.LogLevel)
+	var oldTokenList tokenlist.Model
+	err := libFile.ReadJSONFile(tokenListPath, &oldTokenList)
 	if err != nil {
-		log.WithError(err).Fatal("Failed to parse log level.")
+		log.Debug(err)
+		oldTokenList.Tokens = make([]tokenlist.Token, 0)
 	}
 
-	log.SetLevel(logLevel)
+	oldTokenList.Tokens = append(oldTokenList.Tokens, tokenlist.Token{
+		Asset:   token,
+		Address: tokenID,
+		Pairs:   make([]tokenlist.Pair, 0),
+	})
+
+	return libFile.CreateJSONFile(tokenListPath, &tokenlist.Model{
+		Name:      fmt.Sprintf("Trust Wallet: %s", coin.Coins[chain.ID].Name),
+		LogoURI:   config.Default.URLs.Logo,
+		Timestamp: time.Now().Format(config.Default.TimeFormat),
+		Tokens:    oldTokenList.Tokens,
+		Version:   tokenlist.Version{Major: oldTokenList.Version.Major + 1},
+	})
 }
 
-// Execute adds all child commands to the root command and sets flags appropriately.
-// This is called by main.main(). It only needs to happen once to the rootCmd.
-func Execute() {
-	err := rootCmd.Execute()
+func GetChainAndTokenID(token string) (string, coin.Coin, error) {
+	c, tokenID, err := asset.ParseID(token)
 	if err != nil {
-		os.Exit(1)
+		return "", coin.Coin{}, fmt.Errorf("failed to parse token id: %v", err)
 	}
+
+	chain, ok := coin.Coins[c]
+	if !ok {
+		return "", coin.Coin{}, fmt.Errorf("invalid token")
+	}
+
+	return tokenID, chain, nil
 }