bff dev upgrde

api/server/internal/server/walletapiimp/service.go

@@ -2,60 +2,63 @@ package walletapiimp
 
 import (
 	"context"
-	"fmt"
-	"os"
-	"strings"
 	"time"
 
-	chaingatewayclient "github.com/tech/sendico/gateway/chain/client"
 	api "github.com/tech/sendico/pkg/api/http"
 	"github.com/tech/sendico/pkg/auth"
 	"github.com/tech/sendico/pkg/db/chainassets"
+	"github.com/tech/sendico/pkg/discovery"
 	"github.com/tech/sendico/pkg/merrors"
+	msg "github.com/tech/sendico/pkg/messaging"
 	"github.com/tech/sendico/pkg/mlogger"
 	"github.com/tech/sendico/pkg/mservice"
-	chainv1 "github.com/tech/sendico/pkg/proto/gateway/chain/v1"
 	eapi "github.com/tech/sendico/server/interface/api"
 	mutil "github.com/tech/sendico/server/internal/mutil/param"
 	"go.mongodb.org/mongo-driver/bson/primitive"
 	"go.uber.org/zap"
 )
 
+const (
+	cryptoRail             = "CRYPTO"
+	defaultDialTimeout     = 5 * time.Second
+	defaultCallTimeout     = 10 * time.Second
+	discoveryLookupTimeout = 3 * time.Second
+)
+
 type WalletAPI struct {
 	logger                mlogger.Logger
-	chainGateway          chainWalletClient
+	discovery             *discovery.Client
 	enf                   auth.Enforcer
 	oph                   mutil.ParamHelper
 	wph                   mutil.ParamHelper
 	walletsPermissionRef  primitive.ObjectID
 	balancesPermissionRef primitive.ObjectID
 	assets                chainassets.DB
-}
 
-type chainWalletClient interface {
-	CreateManagedWallet(ctx context.Context, req *chainv1.CreateManagedWalletRequest) (*chainv1.CreateManagedWalletResponse, error)
-	ListManagedWallets(ctx context.Context, req *chainv1.ListManagedWalletsRequest) (*chainv1.ListManagedWalletsResponse, error)
-	GetWalletBalance(ctx context.Context, req *chainv1.GetWalletBalanceRequest) (*chainv1.GetWalletBalanceResponse, error)
-	Close() error
+	// Gateway connection settings
+	dialTimeout time.Duration
+	callTimeout time.Duration
+	insecure    bool
 }
 
 func (a *WalletAPI) Name() mservice.Type { return mservice.ChainWallets }
 
 func (a *WalletAPI) Finish(ctx context.Context) error {
-	if a.chainGateway != nil {
-		if err := a.chainGateway.Close(); err != nil {
-			a.logger.Warn("Failed to close chain gateway client", zap.Error(err))
-		}
+	if a.discovery != nil {
+		a.discovery.Close()
 	}
 	return nil
 }
 
 func CreateAPI(apiCtx eapi.API) (*WalletAPI, error) {
 	p := &WalletAPI{
-		logger: apiCtx.Logger().Named(mservice.Wallets),
-		enf:    apiCtx.Permissions().Enforcer(),
-		oph:    mutil.CreatePH(mservice.Organizations),
-		wph:    mutil.CreatePH(mservice.Wallets),
+		logger:      apiCtx.Logger().Named(mservice.Wallets),
+		enf:         apiCtx.Permissions().Enforcer(),
+		oph:         mutil.CreatePH(mservice.Organizations),
+		wph:         mutil.CreatePH(mservice.Wallets),
+		dialTimeout: defaultDialTimeout,
+		callTimeout: defaultCallTimeout,
+		insecure:    true,
 	}
 
 	var err error
@@ -83,9 +86,22 @@ func CreateAPI(apiCtx eapi.API) (*WalletAPI, error) {
 		p.logger.Error("Failed to fetch service configuration")
 		return nil, merrors.InvalidArgument("No configuration provided")
 	}
-	if err := p.initChainGateway(cfg.ChainGateway); err != nil {
-		p.logger.Error("Failed to initialize chain gateway client", zap.Error(err))
-		return nil, err
+
+	// Apply gateway connection settings from config
+	if gatewayCfg := cfg.ChainGateway; gatewayCfg != nil {
+		if gatewayCfg.DialTimeoutSeconds > 0 {
+			p.dialTimeout = time.Duration(gatewayCfg.DialTimeoutSeconds) * time.Second
+		}
+		if gatewayCfg.CallTimeoutSeconds > 0 {
+			p.callTimeout = time.Duration(gatewayCfg.CallTimeoutSeconds) * time.Second
+		}
+		p.insecure = gatewayCfg.Insecure
+	}
+
+	// Initialize discovery client
+	if err := p.initDiscoveryClient(cfg); err != nil {
+		p.logger.Warn("Failed to initialize discovery client", zap.Error(err))
+		// Not fatal - we can still work without discovery
 	}
 
 	apiCtx.Register().AccountHandler(p.Name(), p.oph.AddRef("/"), api.Get, p.listWallets)
@@ -95,31 +111,22 @@ func CreateAPI(apiCtx eapi.API) (*WalletAPI, error) {
 	return p, nil
 }
 
-func (a *WalletAPI) initChainGateway(cfg *eapi.ChainGatewayConfig) error {
-	if cfg == nil {
-		return merrors.InvalidArgument("chain gateway configuration is not provided")
+func (a *WalletAPI) initDiscoveryClient(cfg *eapi.Config) error {
+	if cfg == nil || cfg.Mw == nil {
+		return nil
 	}
-
-	cfg.Address = strings.TrimSpace(cfg.Address)
-	if cfg.Address == "" {
-		cfg.Address = strings.TrimSpace(os.Getenv(cfg.AddressEnv))
+	msgCfg := cfg.Mw.Messaging
+	if msgCfg.Driver == "" {
+		return nil
 	}
-	if cfg.Address == "" {
-		return merrors.InvalidArgument(fmt.Sprintf("chain gateway address is not specified and address env %s is empty", cfg.AddressEnv))
-	}
-
-	clientCfg := chaingatewayclient.Config{
-		Address:     cfg.Address,
-		DialTimeout: time.Duration(cfg.DialTimeoutSeconds) * time.Second,
-		CallTimeout: time.Duration(cfg.CallTimeoutSeconds) * time.Second,
-		Insecure:    cfg.Insecure,
-	}
-
-	client, err := chaingatewayclient.New(context.Background(), clientCfg)
+	broker, err := msg.CreateMessagingBroker(a.logger.Named("discovery_bus"), &msgCfg)
 	if err != nil {
 		return err
 	}
-
-	a.chainGateway = client
+	client, err := discovery.NewClient(a.logger, broker, nil, string(a.Name()))
+	if err != nil {
+		return err
+	}
+	a.discovery = client
 	return nil
 }