Unifying grid Client (#851)

* fix: remove unused args in create step functions

* change substrate client to grid client usage

* sync with grid client changes

* fix: setup

* test: fix tests

* sync with grid client latest changes

* update grid-client pkg

* update: sync with grid-client updates

* update grid client package

* mod tidy

* refactor: added package grid methods to abstract the access of gridClient

* refactor: rest of refactoring, fixed tests

* refactor: move substrate client to a separate package and make an interface for it

* refactor: move the grid client creation to inside the substrate client and expose grid client

* fix: move generate mnemonic back to substrate file

* update grid-client package

* mod tidy

* fix: linting issues

* fix: error msg

* refactor: change substrate client names to grid client, added grid proxy methods to grid client wrapper

* fix: merge error

* review comments: renaming new substrate client to grid client

* feat: add with network func opt to grid client wrapper, add disable sentry to config

* fmt issue

* fix: rename substrate to grid

* remove unnecessary network parameter

* review comments

* fix: set disable sentry default to true

* fix: added debug, disable sentry as optional args

* review comment: fix func opts to not receive booleans

Author: RawanMostafa08

backend/cmd/cleanup/main.go

@@ -5,16 +5,15 @@ import (
 	cfg "kubecloud/internal/config"
 	"kubecloud/internal/core/models"
 	corepersistence "kubecloud/internal/core/persistence"
+	"kubecloud/internal/infrastructure/gridclient"
 	"kubecloud/internal/infrastructure/persistence"
-	"kubecloud/internal/infrastructure/substrate"
 
 	"os"
 
 	moneycollector "kubecloud/cmd/cleanup/moneycollector"
 
 	"github.com/rs/zerolog/log"
 	"github.com/spf13/viper"
-	// substrate "github.com/threefoldtech/tfchain/clients/tfchain-client-go"
 )
 
 var config cfg.Configuration
@@ -66,17 +65,23 @@ func main() {
 	}
 	defer db.Close()
 
-	substrateClient, err := substrate.NewTFChainClient(
-		config.SystemAccount.Network, config.SystemAccount.Mnemonic, "", "",
-	)
+	clientOpts := []gridclient.ClientOpts{
+		gridclient.WithNetwork(config.SystemAccount.Network),
+	}
+	if config.Debug {
+		clientOpts = append(clientOpts, gridclient.WithDebug())
+	}
+	if config.DisableSentry {
+		clientOpts = append(clientOpts, gridclient.WithDisableSentry())
+	}
 
+	gridClient, err := gridclient.NewGridClient(config.SystemAccount.Mnemonic, clientOpts...)
 	if err != nil {
-		log.Error().Err(err).Msg("Failed to create TF chain client")
+		log.Error().Err(err).Msg("Failed to create grid client")
 		return
 	}
+	defer gridClient.Close()
 
-	defer substrateClient.Close()
-
-	moneyCollector := moneycollector.NewMoneyCollector(corepersistence.NewGormUserRepository(db), config, substrateClient)
+	moneyCollector := moneycollector.NewMoneyCollector(corepersistence.NewGormUserRepository(db), config, gridClient)
 	moneyCollector.CollectMoney()
 }

backend/cmd/cleanup/moneycollector/money_collector.go

@@ -3,27 +3,27 @@ package moneycollector
 import (
 	cfg "kubecloud/internal/config"
 	"kubecloud/internal/core/models"
-	"kubecloud/internal/infrastructure/substrate"
+	"kubecloud/internal/infrastructure/gridclient"
 	"sync"
 
 	"github.com/rs/zerolog/log"
 )
 
 type MoneyCollector struct {
-	userRepo        models.UserRepository
-	config          cfg.Configuration
-	substrateClient substrate.Substrate
+	userRepo   models.UserRepository
+	config     cfg.Configuration
+	gridClient gridclient.GridClient
 }
 
 const (
 	MinBalanceThreshold = 1e5
 )
 
-func NewMoneyCollector(userRepo models.UserRepository, config cfg.Configuration, substrateClient substrate.Substrate) *MoneyCollector {
+func NewMoneyCollector(userRepo models.UserRepository, config cfg.Configuration, gridClient gridclient.GridClient) *MoneyCollector {
 	return &MoneyCollector{
-		userRepo:        userRepo,
-		config:          config,
-		substrateClient: substrateClient,
+		userRepo:   userRepo,
+		config:     config,
+		gridClient: gridClient,
 	}
 }
 
@@ -48,14 +48,14 @@ func (m *MoneyCollector) CollectMoney() {
 				return
 			}
 
-			balance, err := m.substrateClient.GetUserTFTBalance(user.Mnemonic)
+			freeBalance, err := m.gridClient.GetFreeBalanceTFT(user.Mnemonic)
 			if err != nil {
 				log.Error().Err(err).Int("user_id", user.ID).Msg("MoneyCollector: failed to get user balance")
 				return
 			}
-			if balance > MinBalanceThreshold {
-				log.Debug().Int("user_id", user.ID).Uint64("balance", balance).Msg("MoneyCollector: transferring balance to system account")
-				if err := m.substrateClient.TransferTFTsToSystem(balance-MinBalanceThreshold, user.Mnemonic); err != nil {
+			if freeBalance > MinBalanceThreshold {
+				log.Debug().Int("user_id", user.ID).Uint64("balance", freeBalance).Msg("MoneyCollector: transferring balance to system account")
+				if err := m.gridClient.TransferTFTsToSystem(freeBalance-MinBalanceThreshold, user.Mnemonic); err != nil {
 					log.Error().Err(err).Int("user_id", user.ID).Msg("MoneyCollector: failed to transfer balance")
 				}
 				return

backend/config-example.json

@@ -47,6 +47,7 @@
     "public_key_path": "/home/user/.ssh/id_rsa.pub"
   },
   "debug": false,
+  "disable_sentry": true,
   "dev_mode": false,
   "monitor_balance_interval_in_minutes": 120,
   "notify_admins_for_pending_records_in_hours": 24,

backend/internal/api/app/app.go

@@ -88,13 +88,12 @@ func (app *App) registerEWFWorkflows() {
 		app.config,
 		app.core.db,
 		app.communication.mailService,
-		app.infra.substrateClient,
+		app.infra.gridClient,
 		app.security.kycClient,
 		app.security.sponsorAddress,
 		app.security.sponsorKeyPair,
 		app.core.metrics,
 		app.communication.notificationDispatcher,
-		app.infra.gridClient.GridProxyClient,
 		stripeClient,
 	)
 }

backend/internal/api/app/app_dependencies.go

@@ -13,6 +13,7 @@ import (
 	"kubecloud/internal/core/services"
 	"kubecloud/internal/core/workers"
 	grid "kubecloud/internal/infrastructure/grid"
+	"kubecloud/internal/infrastructure/gridclient"
 	"kubecloud/internal/infrastructure/kyc"
 	"kubecloud/internal/infrastructure/logger"
 	"kubecloud/internal/infrastructure/mailservice"
@@ -22,7 +23,6 @@ import (
 	"kubecloud/internal/infrastructure/notification"
 	"kubecloud/internal/infrastructure/persistence"
 	"kubecloud/internal/infrastructure/realtime"
-	"kubecloud/internal/infrastructure/substrate"
 	"kubecloud/internal/infrastructure/telemetry"
 
 	sdktrace "go.opentelemetry.io/otel/sdk/trace"
@@ -87,10 +87,9 @@ type appCommunication struct {
 
 // appInfrastructure contains grid and blockchain related services
 type appInfrastructure struct {
-	gridClient      deployer.TFPluginClient
+	gridClient      gridclient.GridClient
 	firesquidClient graphql.GraphQl
 	graphql         graphql.GraphQl
-	substrateClient substrate.Substrate
 }
 
 func createAppDependencies(ctx context.Context, config cfg.Configuration) (appDependencies, error) {
@@ -269,24 +268,22 @@ func createAppCommunication(config cfg.Configuration, db models.DB, ewfEngine *e
 }
 
 func createAppInfrastructure(config cfg.Configuration, tp *sdktrace.TracerProvider) (appInfrastructure, error) {
-	pluginOpts := []deployer.PluginOpt{
-		deployer.WithNetwork(config.SystemAccount.Network),
-		deployer.WithDisableSentry(),
+
+	clientOpts := []gridclient.ClientOpts{
+		gridclient.WithTracerProvider(tp),
+		gridclient.WithNetwork(config.SystemAccount.Network),
 	}
 	if config.Debug {
-		pluginOpts = append(pluginOpts, deployer.WithLogs())
+		clientOpts = append(clientOpts, gridclient.WithDebug())
 	}
-
-	if tp != nil {
-		pluginOpts = append(pluginOpts, deployer.WithTraceProvider(tp))
+	if config.DisableSentry {
+		clientOpts = append(clientOpts, gridclient.WithDisableSentry())
 	}
 
-	gridClient, err := deployer.NewTFPluginClient(
-		config.SystemAccount.Mnemonic,
-		pluginOpts...,
-	)
+	gridClient, err := gridclient.NewGridClient(config.SystemAccount.Mnemonic, clientOpts...)
+
 	if err != nil {
-		return appInfrastructure{}, fmt.Errorf("failed to create TF grid client: %w", err)
+		return appInfrastructure{}, fmt.Errorf("failed to create grid client: %w", err)
 	}
 
 	fireSquidClient, err := graphql.NewGraphQl(grid.FireSquidURLs[config.SystemAccount.Network]...)
@@ -300,19 +297,10 @@ func createAppInfrastructure(config cfg.Configuration, tp *sdktrace.TracerProvid
 		return appInfrastructure{}, fmt.Errorf("failed to connect to TF graphql: %w", err)
 	}
 
-	tfChainClient, err := substrate.NewTFChainClient(
-		config.SystemAccount.Network, config.SystemAccount.Mnemonic,
-		config.TermsANDConditions.DocumentLink, config.TermsANDConditions.DocumentHash,
-	)
-	if err != nil {
-		return appInfrastructure{}, fmt.Errorf("failed to create tf chain client: %w", err)
-	}
-
 	return appInfrastructure{
 		gridClient:      gridClient,
 		graphql:         graphQl,
 		firesquidClient: fireSquidClient,
-		substrateClient: tfChainClient,
 	}, nil
 }
 
@@ -332,27 +320,24 @@ func (app *App) createHandlers() appHandlers {
 	// Services
 	userService := services.NewUserService(
 		app.core.appCtx, userRepo, voucherRepo, pendingRecordRepo,
-		app.infra.substrateClient, app.core.ewfEngine,
+		app.infra.gridClient, app.core.ewfEngine,
 		app.security.kycClient, app.core.metrics, app.config.MailSender.TimeoutMin,
 		app.config.Admins,
 	)
 
 	statsService := services.NewStatsService(
-		userRepo, clusterRepo, app.infra.gridClient.GridProxyClient,
-		app.infra.substrateClient, app.config.SystemAccount.Mnemonic,
+		userRepo, clusterRepo, app.infra.gridClient, app.config.SystemAccount.Mnemonic,
 	)
 
 	notificationAPIService := services.NewNotificationService(notificationRepo)
 
 	nodeService := services.NewNodeService(
 		userNodesRepo, userRepo, app.core.appCtx, app.core.ewfEngine,
-		app.infra.gridClient, app.infra.substrateClient,
+		app.infra.gridClient,
 	)
 
 	invoiceService := services.NewInvoiceService(
-		invoiceRepo, userRepo, userNodesRepo,
-		app.infra.firesquidClient, app.infra.graphql, app.infra.substrateClient,
-		app.config.Invoice,
+		invoiceRepo, userRepo, app.config.Invoice,
 	)
 
 	deploymentService := services.NewDeploymentService(
@@ -362,7 +347,7 @@ func (app *App) createHandlers() appHandlers {
 
 	adminService := services.NewAdminService(
 		app.core.appCtx, userRepo, userNodesRepo, pendingRecordRepo, voucherRepo,
-		transactionRepo, app.infra.substrateClient, app.core.ewfEngine, app.communication.mailService, app.communication.notificationDispatcher, ewfRepo,
+		transactionRepo, app.infra.gridClient, app.core.ewfEngine, app.communication.mailService, app.communication.notificationDispatcher, ewfRepo,
 	)
 
 	settingsService := services.NewSettingsService(settingsRepo)
@@ -406,7 +391,7 @@ func (app *App) createWorkers() workers.Workers {
 		app.core.appCtx, userRepo, userNodesRepo, invoiceRepo, clusterRepo, pendingRecordRepo,
 		app.communication.mailService, app.infra.gridClient, app.core.ewfEngine,
 		app.communication.notificationDispatcher, app.infra.graphql, app.infra.firesquidClient,
-		app.infra.substrateClient, app.config.Invoice, app.config.SystemAccount.Mnemonic,
+		app.config.Invoice, app.config.SystemAccount.Mnemonic,
 		app.config.Currency, app.config.ClusterHealthCheckIntervalInHours,
 		app.config.NodeHealthCheck.ReservedNodeHealthCheckIntervalInHours, app.config.NodeHealthCheck.ReservedNodeHealthCheckTimeoutInMinutes, app.config.NodeHealthCheck.ReservedNodeHealthCheckWorkersNum, app.config.MonitorBalanceIntervalInMinutes, app.config.NotifyAdminsForPendingRecordsInHours, app.config.UsersBalanceCheckIntervalInHours, app.config.CheckUserDebtIntervalInHours,
 	)

backend/internal/api/handlers/setup.go

@@ -6,8 +6,8 @@ import (
 	cfg "kubecloud/internal/config"
 	"kubecloud/internal/core/models"
 	corepersistence "kubecloud/internal/core/persistence"
+	"kubecloud/internal/infrastructure/gridclient"
 	"kubecloud/internal/infrastructure/persistence"
-	"kubecloud/internal/infrastructure/substrate"
 
 	"os"
 	"os/exec"
@@ -22,13 +22,13 @@ import (
 )
 
 type setup struct {
-	tokenManager    auth.TokenManager
-	substrateClient substrate.Substrate
-	router          *gin.Engine
-
-	userRepo     models.UserRepository
-	voucherRepo  models.VoucherRepository
-	invoicesRepo models.InvoiceRepository
+	tokenManager       auth.TokenManager
+	gridClient         gridclient.GridClient
+	router             *gin.Engine
+	userRepo           models.UserRepository
+	voucherRepo        models.VoucherRepository
+	invoicesRepo       models.InvoiceRepository
+	termsAndConditions cfg.TermsANDConditions
 }
 
 func SetUp(t testing.TB) (setup, error) {
@@ -99,6 +99,8 @@ func SetUp(t testing.TB) (setup, error) {
   },
   "graphql_url": "https://graphql.dev.grid.tf/graphql",
   "firesquid_url": "https://firesquid.dev.grid.tf/graphql",
+  "debug": true,
+  "disable_sentry": true,
   "deployer_workers_num": 3,
   "invoice": {
     "name": "Name",
@@ -140,10 +142,17 @@ func SetUp(t testing.TB) (setup, error) {
 		return setup{}, err
 	}
 
-	substrateClient, err := substrate.NewTFChainClient(
-		configuration.SystemAccount.Network, configuration.SystemAccount.Mnemonic,
-		configuration.TermsANDConditions.DocumentLink, configuration.TermsANDConditions.DocumentHash,
-	)
+	clientOpts := []gridclient.ClientOpts{
+		gridclient.WithNetwork(configuration.SystemAccount.Network),
+	}
+	if configuration.Debug {
+		clientOpts = append(clientOpts, gridclient.WithDebug())
+	}
+	if configuration.DisableSentry {
+		clientOpts = append(clientOpts, gridclient.WithDisableSentry())
+	}
+
+	gridClient, err := gridclient.NewGridClient(configuration.SystemAccount.Mnemonic, clientOpts...)
 	if err != nil {
 		return setup{}, err
 	}
@@ -173,17 +182,17 @@ func SetUp(t testing.TB) (setup, error) {
 
 		// Reset viper to avoid config leakage between tests
 		viper.Reset()
-		substrateClient.Close()
+		gridClient.Close()
 	})
 
 	return setup{
-		tokenManager:    tokenManager,
-		substrateClient: substrateClient,
-		router:          router,
-
-		userRepo:     corepersistence.NewGormUserRepository(db),
-		voucherRepo:  corepersistence.NewGormVoucherRepository(db),
-		invoicesRepo: corepersistence.NewGormInvoiceRepository(db),
+		tokenManager:       tokenManager,
+		gridClient:         gridClient,
+		router:             router,
+		userRepo:           corepersistence.NewGormUserRepository(db),
+		voucherRepo:        corepersistence.NewGormVoucherRepository(db),
+		invoicesRepo:       corepersistence.NewGormInvoiceRepository(db),
+		termsAndConditions: configuration.TermsANDConditions,
 	}, nil
 }
 
@@ -200,7 +209,7 @@ func (s setup) CreateTestUser(t *testing.T, email, username string, hashedPasswo
 	if !mnemonicRequired {
 		mnemonic = ""
 	} else {
-		mnemonic, _, err := s.substrateClient.SetupUserOnTFChain()
+		mnemonic, _, err := s.gridClient.SetupUserOnTFChain(s.termsAndConditions)
 		require.NoError(t, err)
 		sponseeKeyPair, err := auth.KeyPairFromMnemonic(mnemonic)
 		require.NoError(t, err)

backend/internal/api/handlers/user_handler.go

@@ -7,9 +7,9 @@ import (
 	"kubecloud/internal/billing"
 	"kubecloud/internal/core/models"
 	"kubecloud/internal/core/services"
+	"kubecloud/internal/infrastructure/gridclient"
 	"kubecloud/internal/infrastructure/mailservice"
 	"kubecloud/internal/infrastructure/notification"
-	"kubecloud/internal/infrastructure/substrate"
 	"sort"
 	"strconv"
 	"strings"
@@ -739,9 +739,9 @@ func (h *UserHandler) GetUserBalance(c *gin.Context) {
 	}
 
 	OK(c, "Balance is fetched", UserBalanceResponse{
-		BalanceUSD:        substrate.FromUSDMilliCentToUSD(usdMillicentBalance),
-		DebtUSD:           substrate.FromUSDMilliCentToUSD(user.Debt),
-		PendingBalanceUSD: substrate.FromUSDMilliCentToUSD(pendingAmountInUSDMillicent),
+		BalanceUSD:        gridclient.FromUSDMilliCentToUSD(usdMillicentBalance),
+		DebtUSD:           gridclient.FromUSDMilliCentToUSD(user.Debt),
+		PendingBalanceUSD: gridclient.FromUSDMilliCentToUSD(pendingAmountInUSDMillicent),
 	})
 }
 

backend/internal/config/config.go

@@ -30,6 +30,7 @@ type Configuration struct {
 	SSH                                  SSHConfig                     `json:"ssh" validate:"required,dive"`
 	Redis                                RedisConfig                   `json:"redis" validate:"dive"`
 	Debug                                bool                          `json:"debug"`
+	DisableSentry                        bool                          `json:"disable_sentry" default:"true"`
 	DevMode                              bool                          `json:"dev_mode"` // When true, allows empty SendGridKey and uses FakeMailService
 	MonitorBalanceIntervalInMinutes      int                           `json:"monitor_balance_interval_in_minutes" validate:"required,gt=0"`
 	NotifyAdminsForPendingRecordsInHours int                           `json:"notify_admins_for_pending_records_in_hours" validate:"required,gt=0"`
@@ -155,6 +156,8 @@ var DefaultQueueConfig = ewf.QueueMetadata{
 func LoadConfig() (Configuration, error) {
 	var config Configuration
 
+	viper.SetDefault("disable_sentry", true)
+
 	// Use mapstructure to ensure JSON tags are respected
 	decoderConfig := &mapstructure.DecoderConfig{
 		TagName:          "json",