discovery service

api/payments/orchestrator/internal/server/internal/builders.go

@@ -0,0 +1,224 @@
+package serverimp
+
+import (
+	"strings"
+
+	chainclient "github.com/tech/sendico/gateway/chain/client"
+	mntxclient "github.com/tech/sendico/gateway/mntx/client"
+	"github.com/tech/sendico/payments/orchestrator/internal/service/orchestrator"
+	"github.com/tech/sendico/payments/orchestrator/storage/model"
+	"github.com/tech/sendico/pkg/discovery"
+	"github.com/tech/sendico/pkg/mlogger"
+	"github.com/tech/sendico/pkg/payments/rail"
+	"go.uber.org/zap"
+)
+
+func buildCardGatewayRoutes(src map[string]cardGatewayRouteConfig) map[string]orchestrator.CardGatewayRoute {
+	if len(src) == 0 {
+		return nil
+	}
+	result := make(map[string]orchestrator.CardGatewayRoute, len(src))
+	for key, route := range src {
+		trimmedKey := strings.TrimSpace(key)
+		if trimmedKey == "" {
+			continue
+		}
+		result[trimmedKey] = orchestrator.CardGatewayRoute{
+			FundingAddress: strings.TrimSpace(route.FundingAddress),
+			FeeAddress:     strings.TrimSpace(route.FeeAddress),
+			FeeWalletRef:   strings.TrimSpace(route.FeeWalletRef),
+		}
+	}
+	return result
+}
+
+func buildFeeLedgerAccounts(src map[string]string) map[string]string {
+	if len(src) == 0 {
+		return nil
+	}
+	result := make(map[string]string, len(src))
+	for key, account := range src {
+		k := strings.ToLower(strings.TrimSpace(key))
+		v := strings.TrimSpace(account)
+		if k == "" || v == "" {
+			continue
+		}
+		result[k] = v
+	}
+	return result
+}
+
+func buildGatewayRegistry(logger mlogger.Logger, mntxClient mntxclient.Client, src []gatewayInstanceConfig, registry *discovery.Registry) orchestrator.GatewayRegistry {
+	static := buildGatewayInstances(logger, src)
+	staticRegistry := orchestrator.NewGatewayRegistry(logger, mntxClient, static)
+	discoveryRegistry := orchestrator.NewDiscoveryGatewayRegistry(logger, registry)
+	return orchestrator.NewCompositeGatewayRegistry(logger, staticRegistry, discoveryRegistry)
+}
+
+func buildRailGateways(chainClient chainclient.Client, src []gatewayInstanceConfig) map[string]rail.RailGateway {
+	if chainClient == nil || len(src) == 0 {
+		return nil
+	}
+	instances := buildGatewayInstances(nil, src)
+	if len(instances) == 0 {
+		return nil
+	}
+	result := map[string]rail.RailGateway{}
+	for _, inst := range instances {
+		if inst == nil || !inst.IsEnabled {
+			continue
+		}
+		if inst.Rail != model.RailCrypto {
+			continue
+		}
+		cfg := chainclient.RailGatewayConfig{
+			Rail:    string(inst.Rail),
+			Network: inst.Network,
+			Capabilities: rail.RailCapabilities{
+				CanPayIn:               inst.Capabilities.CanPayIn,
+				CanPayOut:              inst.Capabilities.CanPayOut,
+				CanReadBalance:         inst.Capabilities.CanReadBalance,
+				CanSendFee:             inst.Capabilities.CanSendFee,
+				RequiresObserveConfirm: inst.Capabilities.RequiresObserveConfirm,
+			},
+		}
+		result[inst.ID] = chainclient.NewRailGateway(chainClient, cfg)
+	}
+	if len(result) == 0 {
+		return nil
+	}
+	return result
+}
+
+func buildGatewayInstances(logger mlogger.Logger, src []gatewayInstanceConfig) []*model.GatewayInstanceDescriptor {
+	if len(src) == 0 {
+		return nil
+	}
+	if logger != nil {
+		logger = logger.Named("gateway_instances")
+	}
+	result := make([]*model.GatewayInstanceDescriptor, 0, len(src))
+	for _, cfg := range src {
+		id := strings.TrimSpace(cfg.ID)
+		if id == "" {
+			if logger != nil {
+				logger.Warn("Gateway instance skipped: missing id")
+			}
+			continue
+		}
+		rail := parseRail(cfg.Rail)
+		if rail == model.RailUnspecified {
+			if logger != nil {
+				logger.Warn("Gateway instance skipped: invalid rail", zap.String("id", id), zap.String("rail", cfg.Rail))
+			}
+			continue
+		}
+		enabled := true
+		if cfg.IsEnabled != nil {
+			enabled = *cfg.IsEnabled
+		}
+		result = append(result, &model.GatewayInstanceDescriptor{
+			ID:         id,
+			Rail:       rail,
+			Network:    strings.ToUpper(strings.TrimSpace(cfg.Network)),
+			Currencies: normalizeCurrencies(cfg.Currencies),
+			Capabilities: model.RailCapabilities{
+				CanPayIn:               cfg.Capabilities.CanPayIn,
+				CanPayOut:              cfg.Capabilities.CanPayOut,
+				CanReadBalance:         cfg.Capabilities.CanReadBalance,
+				CanSendFee:             cfg.Capabilities.CanSendFee,
+				RequiresObserveConfirm: cfg.Capabilities.RequiresObserveConfirm,
+			},
+			Limits:    buildGatewayLimits(cfg.Limits),
+			Version:   strings.TrimSpace(cfg.Version),
+			IsEnabled: enabled,
+		})
+	}
+	return result
+}
+
+func parseRail(value string) model.Rail {
+	switch strings.ToUpper(strings.TrimSpace(value)) {
+	case string(model.RailCrypto):
+		return model.RailCrypto
+	case string(model.RailProviderSettlement):
+		return model.RailProviderSettlement
+	case string(model.RailLedger):
+		return model.RailLedger
+	case string(model.RailCardPayout):
+		return model.RailCardPayout
+	case string(model.RailFiatOnRamp):
+		return model.RailFiatOnRamp
+	default:
+		return model.RailUnspecified
+	}
+}
+
+func normalizeCurrencies(values []string) []string {
+	if len(values) == 0 {
+		return nil
+	}
+	seen := map[string]bool{}
+	result := make([]string, 0, len(values))
+	for _, value := range values {
+		clean := strings.ToUpper(strings.TrimSpace(value))
+		if clean == "" || seen[clean] {
+			continue
+		}
+		seen[clean] = true
+		result = append(result, clean)
+	}
+	return result
+}
+
+func buildGatewayLimits(cfg limitsConfig) model.Limits {
+	limits := model.Limits{
+		MinAmount:      strings.TrimSpace(cfg.MinAmount),
+		MaxAmount:      strings.TrimSpace(cfg.MaxAmount),
+		PerTxMaxFee:    strings.TrimSpace(cfg.PerTxMaxFee),
+		PerTxMinAmount: strings.TrimSpace(cfg.PerTxMinAmount),
+		PerTxMaxAmount: strings.TrimSpace(cfg.PerTxMaxAmount),
+	}
+
+	if len(cfg.VolumeLimit) > 0 {
+		limits.VolumeLimit = map[string]string{}
+		for key, value := range cfg.VolumeLimit {
+			bucket := strings.TrimSpace(key)
+			amount := strings.TrimSpace(value)
+			if bucket == "" || amount == "" {
+				continue
+			}
+			limits.VolumeLimit[bucket] = amount
+		}
+	}
+
+	if len(cfg.VelocityLimit) > 0 {
+		limits.VelocityLimit = map[string]int{}
+		for key, value := range cfg.VelocityLimit {
+			bucket := strings.TrimSpace(key)
+			if bucket == "" {
+				continue
+			}
+			limits.VelocityLimit[bucket] = value
+		}
+	}
+
+	if len(cfg.CurrencyLimits) > 0 {
+		limits.CurrencyLimits = map[string]model.LimitsOverride{}
+		for key, override := range cfg.CurrencyLimits {
+			currency := strings.ToUpper(strings.TrimSpace(key))
+			if currency == "" {
+				continue
+			}
+			limits.CurrencyLimits[currency] = model.LimitsOverride{
+				MaxVolume: strings.TrimSpace(override.MaxVolume),
+				MinAmount: strings.TrimSpace(override.MinAmount),
+				MaxAmount: strings.TrimSpace(override.MaxAmount),
+				MaxFee:    strings.TrimSpace(override.MaxFee),
+				MaxOps:    override.MaxOps,
+			}
+		}
+	}
+
+	return limits
+}

api/payments/orchestrator/internal/server/internal/clients.go

@@ -0,0 +1,150 @@
+package serverimp
+
+import (
+	"context"
+	"crypto/tls"
+
+	oracleclient "github.com/tech/sendico/fx/oracle/client"
+	chainclient "github.com/tech/sendico/gateway/chain/client"
+	mntxclient "github.com/tech/sendico/gateway/mntx/client"
+	ledgerclient "github.com/tech/sendico/ledger/client"
+	feesv1 "github.com/tech/sendico/pkg/proto/billing/fees/v1"
+	"go.uber.org/zap"
+	"google.golang.org/grpc"
+	"google.golang.org/grpc/credentials"
+	"google.golang.org/grpc/credentials/insecure"
+)
+
+func (i *Imp) initFeesClient(cfg clientConfig) (feesv1.FeeEngineClient, *grpc.ClientConn) {
+	addr := cfg.address()
+	if addr == "" {
+		return nil, nil
+	}
+
+	dialCtx, cancel := context.WithTimeout(context.Background(), cfg.dialTimeout())
+	defer cancel()
+
+	creds := credentials.NewTLS(&tls.Config{})
+	if cfg.InsecureTransport {
+		creds = insecure.NewCredentials()
+	}
+
+	conn, err := grpc.DialContext(dialCtx, addr, grpc.WithTransportCredentials(creds))
+	if err != nil {
+		i.logger.Warn("Failed to connect to fees service", zap.String("address", addr), zap.Error(err))
+		return nil, nil
+	}
+
+	i.logger.Info("Connected to fees service", zap.String("address", addr))
+	return feesv1.NewFeeEngineClient(conn), conn
+}
+
+func (i *Imp) initLedgerClient(cfg clientConfig) ledgerclient.Client {
+	addr := cfg.address()
+	if addr == "" {
+		return nil
+	}
+
+	ctx, cancel := context.WithTimeout(context.Background(), cfg.dialTimeout())
+	defer cancel()
+
+	client, err := ledgerclient.New(ctx, ledgerclient.Config{
+		Address:     addr,
+		DialTimeout: cfg.dialTimeout(),
+		CallTimeout: cfg.callTimeout(),
+		Insecure:    cfg.InsecureTransport,
+	})
+	if err != nil {
+		i.logger.Warn("Failed to connect to ledger service", zap.String("address", addr), zap.Error(err))
+		return nil
+	}
+	i.logger.Info("Connected to ledger service", zap.String("address", addr))
+	return client
+}
+
+func (i *Imp) initGatewayClient(cfg clientConfig) chainclient.Client {
+	addr := cfg.address()
+	if addr == "" {
+		return nil
+	}
+
+	ctx, cancel := context.WithTimeout(context.Background(), cfg.dialTimeout())
+	defer cancel()
+
+	client, err := chainclient.New(ctx, chainclient.Config{
+		Address:     addr,
+		DialTimeout: cfg.dialTimeout(),
+		CallTimeout: cfg.callTimeout(),
+		Insecure:    cfg.InsecureTransport,
+	})
+	if err != nil {
+		i.logger.Warn("failed to connect to chain gateway service", zap.String("address", addr), zap.Error(err))
+		return nil
+	}
+	i.logger.Info("connected to chain gateway service", zap.String("address", addr))
+	return client
+}
+
+func (i *Imp) initMntxClient(cfg clientConfig) mntxclient.Client {
+	addr := cfg.address()
+	if addr == "" {
+		return nil
+	}
+
+	ctx, cancel := context.WithTimeout(context.Background(), cfg.dialTimeout())
+	defer cancel()
+
+	client, err := mntxclient.New(ctx, mntxclient.Config{
+		Address:     addr,
+		DialTimeout: cfg.dialTimeout(),
+		CallTimeout: cfg.callTimeout(),
+		Logger:      i.logger.Named("client.mntx"),
+	})
+	if err != nil {
+		i.logger.Warn("Failed to connect to mntx gateway service", zap.String("address", addr), zap.Error(err))
+		return nil
+	}
+	i.logger.Info("Connected to mntx gateway service", zap.String("address", addr))
+	return client
+}
+
+func (i *Imp) initOracleClient(cfg clientConfig) oracleclient.Client {
+	addr := cfg.address()
+	if addr == "" {
+		return nil
+	}
+
+	ctx, cancel := context.WithTimeout(context.Background(), cfg.dialTimeout())
+	defer cancel()
+
+	client, err := oracleclient.New(ctx, oracleclient.Config{
+		Address:     addr,
+		DialTimeout: cfg.dialTimeout(),
+		CallTimeout: cfg.callTimeout(),
+		Insecure:    cfg.InsecureTransport,
+	})
+	if err != nil {
+		i.logger.Warn("Failed to connect to oracle service", zap.String("address", addr), zap.Error(err))
+		return nil
+	}
+	i.logger.Info("Connected to oracle service", zap.String("address", addr))
+	return client
+}
+
+func (i *Imp) closeClients() {
+	if i.ledgerClient != nil {
+		_ = i.ledgerClient.Close()
+	}
+	if i.gatewayClient != nil {
+		_ = i.gatewayClient.Close()
+	}
+	if i.mntxClient != nil {
+		_ = i.mntxClient.Close()
+	}
+	if i.oracleClient != nil {
+		_ = i.oracleClient.Close()
+	}
+	if i.feesConn != nil {
+		_ = i.feesConn.Close()
+	}
+}

api/payments/orchestrator/internal/server/internal/config.go

@@ -0,0 +1,135 @@
+package serverimp
+
+import (
+	"os"
+	"strings"
+	"time"
+
+	"github.com/tech/sendico/pkg/api/routers"
+	"github.com/tech/sendico/pkg/server/grpcapp"
+	"go.uber.org/zap"
+	"gopkg.in/yaml.v3"
+)
+
+type config struct {
+	*grpcapp.Config  `yaml:",inline"`
+	Fees             clientConfig                      `yaml:"fees"`
+	Ledger           clientConfig                      `yaml:"ledger"`
+	Gateway          clientConfig                      `yaml:"gateway"`
+	Mntx             clientConfig                      `yaml:"mntx"`
+	Oracle           clientConfig                      `yaml:"oracle"`
+	CardGateways     map[string]cardGatewayRouteConfig `yaml:"card_gateways"`
+	FeeAccounts      map[string]string                 `yaml:"fee_ledger_accounts"`
+	GatewayInstances []gatewayInstanceConfig           `yaml:"gateway_instances"`
+}
+
+type clientConfig struct {
+	Address           string `yaml:"address"`
+	DialTimeoutSecs   int    `yaml:"dial_timeout_seconds"`
+	CallTimeoutSecs   int    `yaml:"call_timeout_seconds"`
+	InsecureTransport bool   `yaml:"insecure"`
+}
+
+type cardGatewayRouteConfig struct {
+	FundingAddress string `yaml:"funding_address"`
+	FeeAddress     string `yaml:"fee_address"`
+	FeeWalletRef   string `yaml:"fee_wallet_ref"`
+}
+
+type gatewayInstanceConfig struct {
+	ID           string                    `yaml:"id"`
+	Rail         string                    `yaml:"rail"`
+	Network      string                    `yaml:"network"`
+	Currencies   []string                  `yaml:"currencies"`
+	Capabilities gatewayCapabilitiesConfig `yaml:"capabilities"`
+	Limits       limitsConfig              `yaml:"limits"`
+	Version      string                    `yaml:"version"`
+	IsEnabled    *bool                     `yaml:"is_enabled"`
+}
+
+type gatewayCapabilitiesConfig struct {
+	CanPayIn               bool `yaml:"can_pay_in"`
+	CanPayOut              bool `yaml:"can_pay_out"`
+	CanReadBalance         bool `yaml:"can_read_balance"`
+	CanSendFee             bool `yaml:"can_send_fee"`
+	RequiresObserveConfirm bool `yaml:"requires_observe_confirm"`
+}
+
+type limitsConfig struct {
+	MinAmount      string                       `yaml:"min_amount"`
+	MaxAmount      string                       `yaml:"max_amount"`
+	PerTxMaxFee    string                       `yaml:"per_tx_max_fee"`
+	PerTxMinAmount string                       `yaml:"per_tx_min_amount"`
+	PerTxMaxAmount string                       `yaml:"per_tx_max_amount"`
+	VolumeLimit    map[string]string            `yaml:"volume_limit"`
+	VelocityLimit  map[string]int               `yaml:"velocity_limit"`
+	CurrencyLimits map[string]limitsOverrideCfg `yaml:"currency_limits"`
+}
+
+type limitsOverrideCfg struct {
+	MaxVolume string `yaml:"max_volume"`
+	MinAmount string `yaml:"min_amount"`
+	MaxAmount string `yaml:"max_amount"`
+	MaxFee    string `yaml:"max_fee"`
+	MaxOps    int    `yaml:"max_ops"`
+}
+
+func (c clientConfig) address() string {
+	return strings.TrimSpace(c.Address)
+}
+
+func (c clientConfig) dialTimeout() time.Duration {
+	if c.DialTimeoutSecs <= 0 {
+		return 5 * time.Second
+	}
+	return time.Duration(c.DialTimeoutSecs) * time.Second
+}
+
+func (c clientConfig) callTimeout() time.Duration {
+	if c.CallTimeoutSecs <= 0 {
+		return 3 * time.Second
+	}
+	return time.Duration(c.CallTimeoutSecs) * time.Second
+}
+
+func (i *Imp) loadConfig() (*config, error) {
+	data, err := os.ReadFile(i.file)
+	if err != nil {
+		i.logger.Error("Could not read configuration file", zap.String("config_file", i.file), zap.Error(err))
+		return nil, err
+	}
+
+	cfg := &config{Config: &grpcapp.Config{}}
+	if err := yaml.Unmarshal(data, cfg); err != nil {
+		i.logger.Error("Failed to parse configuration", zap.Error(err))
+		return nil, err
+	}
+
+	if cfg.Runtime == nil {
+		cfg.Runtime = &grpcapp.RuntimeConfig{ShutdownTimeoutSeconds: 15}
+	}
+
+	if cfg.GRPC == nil {
+		cfg.GRPC = &routers.GRPCConfig{
+			Network:          "tcp",
+			Address:          ":50062",
+			EnableReflection: true,
+			EnableHealth:     true,
+		}
+	} else {
+		if strings.TrimSpace(cfg.GRPC.Address) == "" {
+			cfg.GRPC.Address = ":50062"
+		}
+		if strings.TrimSpace(cfg.GRPC.Network) == "" {
+			cfg.GRPC.Network = "tcp"
+		}
+	}
+
+	if cfg.Metrics == nil {
+		cfg.Metrics = &grpcapp.MetricsConfig{Address: ":9403"}
+	} else if strings.TrimSpace(cfg.Metrics.Address) == "" {
+		cfg.Metrics.Address = ":9403"
+	}
+
+	return cfg, nil
+}

api/payments/orchestrator/internal/server/internal/dependencies.go

@@ -0,0 +1,84 @@
+package serverimp
+
+import (
+	oracleclient "github.com/tech/sendico/fx/oracle/client"
+	chainclient "github.com/tech/sendico/gateway/chain/client"
+	mntxclient "github.com/tech/sendico/gateway/mntx/client"
+	ledgerclient "github.com/tech/sendico/ledger/client"
+	"github.com/tech/sendico/payments/orchestrator/internal/service/orchestrator"
+	feesv1 "github.com/tech/sendico/pkg/proto/billing/fees/v1"
+)
+
+type orchestratorDeps struct {
+	feesClient    feesv1.FeeEngineClient
+	ledgerClient  ledgerclient.Client
+	gatewayClient chainclient.Client
+	mntxClient    mntxclient.Client
+	oracleClient  oracleclient.Client
+}
+
+func (i *Imp) initDependencies(cfg *config) *orchestratorDeps {
+	deps := &orchestratorDeps{}
+	if cfg == nil {
+		return deps
+	}
+
+	deps.feesClient, i.feesConn = i.initFeesClient(cfg.Fees)
+
+	deps.ledgerClient = i.initLedgerClient(cfg.Ledger)
+	if deps.ledgerClient != nil {
+		i.ledgerClient = deps.ledgerClient
+	}
+
+	deps.gatewayClient = i.initGatewayClient(cfg.Gateway)
+	if deps.gatewayClient != nil {
+		i.gatewayClient = deps.gatewayClient
+	}
+
+	deps.mntxClient = i.initMntxClient(cfg.Mntx)
+	if deps.mntxClient != nil {
+		i.mntxClient = deps.mntxClient
+	}
+
+	deps.oracleClient = i.initOracleClient(cfg.Oracle)
+	if deps.oracleClient != nil {
+		i.oracleClient = deps.oracleClient
+	}
+
+	return deps
+}
+
+func (i *Imp) buildServiceOptions(cfg *config, deps *orchestratorDeps) []orchestrator.Option {
+	if cfg == nil || deps == nil {
+		return nil
+	}
+	opts := []orchestrator.Option{}
+	if deps.feesClient != nil {
+		opts = append(opts, orchestrator.WithFeeEngine(deps.feesClient, cfg.Fees.callTimeout()))
+	}
+	if deps.ledgerClient != nil {
+		opts = append(opts, orchestrator.WithLedgerClient(deps.ledgerClient))
+	}
+	if deps.gatewayClient != nil {
+		opts = append(opts, orchestrator.WithChainGatewayClient(deps.gatewayClient))
+	}
+	if railGateways := buildRailGateways(deps.gatewayClient, cfg.GatewayInstances); len(railGateways) > 0 {
+		opts = append(opts, orchestrator.WithRailGateways(railGateways))
+	}
+	if deps.mntxClient != nil {
+		opts = append(opts, orchestrator.WithMntxGateway(deps.mntxClient))
+	}
+	if deps.oracleClient != nil {
+		opts = append(opts, orchestrator.WithOracleClient(deps.oracleClient))
+	}
+	if routes := buildCardGatewayRoutes(cfg.CardGateways); len(routes) > 0 {
+		opts = append(opts, orchestrator.WithCardGatewayRoutes(routes))
+	}
+	if feeAccounts := buildFeeLedgerAccounts(cfg.FeeAccounts); len(feeAccounts) > 0 {
+		opts = append(opts, orchestrator.WithFeeLedgerAccounts(feeAccounts))
+	}
+	if registry := buildGatewayRegistry(i.logger, deps.mntxClient, cfg.GatewayInstances, i.discoveryReg); registry != nil {
+		opts = append(opts, orchestrator.WithGatewayRegistry(registry))
+	}
+	return opts
+}

api/payments/orchestrator/internal/server/internal/discovery.go

@@ -0,0 +1,50 @@
+package serverimp
+
+import (
+	"github.com/tech/sendico/payments/orchestrator/internal/appversion"
+	"github.com/tech/sendico/pkg/discovery"
+	msg "github.com/tech/sendico/pkg/messaging"
+	msgproducer "github.com/tech/sendico/pkg/messaging/producer"
+	"github.com/tech/sendico/pkg/mservice"
+	"go.uber.org/zap"
+)
+
+func (i *Imp) initDiscovery(cfg *config) {
+	if cfg == nil || cfg.Messaging == nil || cfg.Messaging.Driver == "" {
+		return
+	}
+	logger := i.logger.Named("discovery")
+	broker, err := msg.CreateMessagingBroker(logger.Named("bus"), cfg.Messaging)
+	if err != nil {
+		i.logger.Warn("Failed to initialise discovery broker", zap.Error(err))
+		return
+	}
+	producer := msgproducer.NewProducer(logger.Named("producer"), broker)
+	registry := discovery.NewRegistry()
+	watcher, err := discovery.NewRegistryWatcher(i.logger, broker, registry)
+	if err != nil {
+		i.logger.Warn("Failed to initialise discovery registry watcher", zap.Error(err))
+	} else if err := watcher.Start(); err != nil {
+		i.logger.Warn("Failed to start discovery registry watcher", zap.Error(err))
+	} else {
+		i.discoveryWatcher = watcher
+		i.discoveryReg = registry
+		i.logger.Info("Discovery registry watcher started")
+	}
+	announce := discovery.Announcement{
+		Service:    "PAYMENTS_ORCHESTRATOR",
+		Operations: []string{"payment.quote", "payment.initiate"},
+		Version:    appversion.Create().Short(),
+	}
+	i.discoveryAnnouncer = discovery.NewAnnouncer(i.logger, producer, string(mservice.PaymentOrchestrator), announce)
+	i.discoveryAnnouncer.Start()
+}
+
+func (i *Imp) stopDiscovery() {
+	if i.discoveryAnnouncer != nil {
+		i.discoveryAnnouncer.Stop()
+	}
+	if i.discoveryWatcher != nil {
+		i.discoveryWatcher.Stop()
+	}
+}

api/payments/orchestrator/internal/server/internal/lifecycle.go

@@ -0,0 +1,18 @@
+package serverimp
+
+import (
+	"context"
+	"time"
+)
+
+func (i *Imp) shutdownApp() {
+	if i.app != nil {
+		timeout := 15 * time.Second
+		if i.config != nil && i.config.Runtime != nil {
+			timeout = i.config.Runtime.ShutdownTimeout()
+		}
+		ctx, cancel := context.WithTimeout(context.Background(), timeout)
+		i.app.Shutdown(ctx)
+		cancel()
+	}
+}

api/payments/orchestrator/internal/server/internal/serverimp.go

@@ -1,136 +1,15 @@
 package serverimp
 
 import (
-	"context"
-	"crypto/tls"
-	"os"
-	"strings"
-	"time"
-
-	oracleclient "github.com/tech/sendico/fx/oracle/client"
-	chainclient "github.com/tech/sendico/gateway/chain/client"
-	mntxclient "github.com/tech/sendico/gateway/mntx/client"
-	ledgerclient "github.com/tech/sendico/ledger/client"
-	"github.com/tech/sendico/payments/orchestrator/internal/appversion"
 	"github.com/tech/sendico/payments/orchestrator/internal/service/orchestrator"
 	"github.com/tech/sendico/payments/orchestrator/storage"
-	"github.com/tech/sendico/payments/orchestrator/storage/model"
 	mongostorage "github.com/tech/sendico/payments/orchestrator/storage/mongo"
-	"github.com/tech/sendico/pkg/api/routers"
 	"github.com/tech/sendico/pkg/db"
-	"github.com/tech/sendico/pkg/discovery"
 	msg "github.com/tech/sendico/pkg/messaging"
-	msgproducer "github.com/tech/sendico/pkg/messaging/producer"
 	"github.com/tech/sendico/pkg/mlogger"
-	"github.com/tech/sendico/pkg/mservice"
-	"github.com/tech/sendico/pkg/payments/rail"
-	feesv1 "github.com/tech/sendico/pkg/proto/billing/fees/v1"
 	"github.com/tech/sendico/pkg/server/grpcapp"
-	"go.uber.org/zap"
-	"google.golang.org/grpc"
-	"google.golang.org/grpc/credentials"
-	"google.golang.org/grpc/credentials/insecure"
-	"gopkg.in/yaml.v3"
 )
 
-type Imp struct {
-	logger mlogger.Logger
-	file   string
-	debug  bool
-
-	config             *config
-	app                *grpcapp.App[storage.Repository]
-	discoverySvc       *discovery.RegistryService
-	discoveryReg       *discovery.Registry
-	discoveryAnnouncer *discovery.Announcer
-	feesConn           *grpc.ClientConn
-	ledgerClient       ledgerclient.Client
-	gatewayClient      chainclient.Client
-	mntxClient         mntxclient.Client
-	oracleClient       oracleclient.Client
-}
-
-type config struct {
-	*grpcapp.Config  `yaml:",inline"`
-	Fees             clientConfig                      `yaml:"fees"`
-	Ledger           clientConfig                      `yaml:"ledger"`
-	Gateway          clientConfig                      `yaml:"gateway"`
-	Mntx             clientConfig                      `yaml:"mntx"`
-	Oracle           clientConfig                      `yaml:"oracle"`
-	CardGateways     map[string]cardGatewayRouteConfig `yaml:"card_gateways"`
-	FeeAccounts      map[string]string                 `yaml:"fee_ledger_accounts"`
-	GatewayInstances []gatewayInstanceConfig           `yaml:"gateway_instances"`
-}
-
-type clientConfig struct {
-	Address           string `yaml:"address"`
-	DialTimeoutSecs   int    `yaml:"dial_timeout_seconds"`
-	CallTimeoutSecs   int    `yaml:"call_timeout_seconds"`
-	InsecureTransport bool   `yaml:"insecure"`
-}
-
-type cardGatewayRouteConfig struct {
-	FundingAddress string `yaml:"funding_address"`
-	FeeAddress     string `yaml:"fee_address"`
-	FeeWalletRef   string `yaml:"fee_wallet_ref"`
-}
-
-type gatewayInstanceConfig struct {
-	ID           string                    `yaml:"id"`
-	Rail         string                    `yaml:"rail"`
-	Network      string                    `yaml:"network"`
-	Currencies   []string                  `yaml:"currencies"`
-	Capabilities gatewayCapabilitiesConfig `yaml:"capabilities"`
-	Limits       limitsConfig              `yaml:"limits"`
-	Version      string                    `yaml:"version"`
-	IsEnabled    *bool                     `yaml:"is_enabled"`
-}
-
-type gatewayCapabilitiesConfig struct {
-	CanPayIn               bool `yaml:"can_pay_in"`
-	CanPayOut              bool `yaml:"can_pay_out"`
-	CanReadBalance         bool `yaml:"can_read_balance"`
-	CanSendFee             bool `yaml:"can_send_fee"`
-	RequiresObserveConfirm bool `yaml:"requires_observe_confirm"`
-}
-
-type limitsConfig struct {
-	MinAmount      string                       `yaml:"min_amount"`
-	MaxAmount      string                       `yaml:"max_amount"`
-	PerTxMaxFee    string                       `yaml:"per_tx_max_fee"`
-	PerTxMinAmount string                       `yaml:"per_tx_min_amount"`
-	PerTxMaxAmount string                       `yaml:"per_tx_max_amount"`
-	VolumeLimit    map[string]string            `yaml:"volume_limit"`
-	VelocityLimit  map[string]int               `yaml:"velocity_limit"`
-	CurrencyLimits map[string]limitsOverrideCfg `yaml:"currency_limits"`
-}
-
-type limitsOverrideCfg struct {
-	MaxVolume string `yaml:"max_volume"`
-	MinAmount string `yaml:"min_amount"`
-	MaxAmount string `yaml:"max_amount"`
-	MaxFee    string `yaml:"max_fee"`
-	MaxOps    int    `yaml:"max_ops"`
-}
-
-func (c clientConfig) address() string {
-	return strings.TrimSpace(c.Address)
-}
-
-func (c clientConfig) dialTimeout() time.Duration {
-	if c.DialTimeoutSecs <= 0 {
-		return 5 * time.Second
-	}
-	return time.Duration(c.DialTimeoutSecs) * time.Second
-}
-
-func (c clientConfig) callTimeout() time.Duration {
-	if c.CallTimeoutSecs <= 0 {
-		return 3 * time.Second
-	}
-	return time.Duration(c.CallTimeoutSecs) * time.Second
-}
-
 func Create(logger mlogger.Logger, file string, debug bool) (*Imp, error) {
 	return &Imp{
 		logger: logger.Named("server"),
@@ -140,37 +19,9 @@ func Create(logger mlogger.Logger, file string, debug bool) (*Imp, error) {
 }
 
 func (i *Imp) Shutdown() {
-	if i.discoveryAnnouncer != nil {
-		i.discoveryAnnouncer.Stop()
-	}
-	if i.discoverySvc != nil {
-		i.discoverySvc.Stop()
-	}
-	if i.app != nil {
-		timeout := 15 * time.Second
-		if i.config != nil && i.config.Runtime != nil {
-			timeout = i.config.Runtime.ShutdownTimeout()
-		}
-		ctx, cancel := context.WithTimeout(context.Background(), timeout)
-		i.app.Shutdown(ctx)
-		cancel()
-	}
-
-	if i.ledgerClient != nil {
-		_ = i.ledgerClient.Close()
-	}
-	if i.gatewayClient != nil {
-		_ = i.gatewayClient.Close()
-	}
-	if i.mntxClient != nil {
-		_ = i.mntxClient.Close()
-	}
-	if i.oracleClient != nil {
-		_ = i.oracleClient.Close()
-	}
-	if i.feesConn != nil {
-		_ = i.feesConn.Close()
-	}
+	i.stopDiscovery()
+	i.shutdownApp()
+	i.closeClients()
 }
 
 func (i *Imp) Start() error {
@@ -180,90 +31,16 @@ func (i *Imp) Start() error {
 	}
 	i.config = cfg
 
-	if cfg.Messaging != nil && cfg.Messaging.Driver != "" {
-		broker, err := msg.CreateMessagingBroker(i.logger.Named("discovery_bus"), cfg.Messaging)
-		if err != nil {
-			i.logger.Warn("Failed to initialise discovery broker", zap.Error(err))
-		} else {
-			producer := msgproducer.NewProducer(i.logger.Named("discovery_producer"), broker)
-			registry := discovery.NewRegistry()
-			svc, err := discovery.NewRegistryService(i.logger, broker, producer, registry, string(mservice.PaymentOrchestrator))
-			if err != nil {
-				i.logger.Warn("Failed to start discovery registry service", zap.Error(err))
-			} else {
-				svc.Start()
-				i.discoverySvc = svc
-				i.discoveryReg = registry
-				i.logger.Info("Discovery registry service started")
-			}
-			announce := discovery.Announcement{
-				Service:    "PAYMENTS_ORCHESTRATOR",
-				Operations: []string{"payment.quote", "payment.initiate"},
-				Version:    appversion.Create().Short(),
-			}
-			i.discoveryAnnouncer = discovery.NewAnnouncer(i.logger, producer, string(mservice.PaymentOrchestrator), announce)
-			i.discoveryAnnouncer.Start()
-		}
-	}
+	i.initDiscovery(cfg)
 
 	repoFactory := func(logger mlogger.Logger, conn *db.MongoConnection) (storage.Repository, error) {
 		return mongostorage.New(logger, conn)
 	}
 
-	feesClient, feesConn := i.initFeesClient(cfg.Fees)
-	if feesConn != nil {
-		i.feesConn = feesConn
-	}
-
-	ledgerClient := i.initLedgerClient(cfg.Ledger)
-	if ledgerClient != nil {
-		i.ledgerClient = ledgerClient
-	}
-
-	gatewayClient := i.initGatewayClient(cfg.Gateway)
-	if gatewayClient != nil {
-		i.gatewayClient = gatewayClient
-	}
-
-	mntxClient := i.initMntxClient(cfg.Mntx)
-	if mntxClient != nil {
-		i.mntxClient = mntxClient
-	}
-
-	oracleClient := i.initOracleClient(cfg.Oracle)
-	if oracleClient != nil {
-		i.oracleClient = oracleClient
-	}
+	deps := i.initDependencies(cfg)
 
 	serviceFactory := func(logger mlogger.Logger, repo storage.Repository, producer msg.Producer) (grpcapp.Service, error) {
-		opts := []orchestrator.Option{}
-		if feesClient != nil {
-			opts = append(opts, orchestrator.WithFeeEngine(feesClient, cfg.Fees.callTimeout()))
-		}
-		if ledgerClient != nil {
-			opts = append(opts, orchestrator.WithLedgerClient(ledgerClient))
-		}
-		if gatewayClient != nil {
-			opts = append(opts, orchestrator.WithChainGatewayClient(gatewayClient))
-		}
-		if railGateways := buildRailGateways(gatewayClient, cfg.GatewayInstances); len(railGateways) > 0 {
-			opts = append(opts, orchestrator.WithRailGateways(railGateways))
-		}
-		if mntxClient != nil {
-			opts = append(opts, orchestrator.WithMntxGateway(mntxClient))
-		}
-		if oracleClient != nil {
-			opts = append(opts, orchestrator.WithOracleClient(oracleClient))
-		}
-		if routes := buildCardGatewayRoutes(cfg.CardGateways); len(routes) > 0 {
-			opts = append(opts, orchestrator.WithCardGatewayRoutes(routes))
-		}
-		if feeAccounts := buildFeeLedgerAccounts(cfg.FeeAccounts); len(feeAccounts) > 0 {
-			opts = append(opts, orchestrator.WithFeeLedgerAccounts(feeAccounts))
-		}
-		if registry := buildGatewayRegistry(i.logger, mntxClient, cfg.GatewayInstances, i.discoveryReg); registry != nil {
-			opts = append(opts, orchestrator.WithGatewayRegistry(registry))
-		}
+		opts := i.buildServiceOptions(cfg, deps)
 		return orchestrator.NewService(logger, repo, opts...), nil
 	}
 
@@ -275,371 +52,3 @@ func (i *Imp) Start() error {
 
 	return i.app.Start()
 }
-
-func (i *Imp) initFeesClient(cfg clientConfig) (feesv1.FeeEngineClient, *grpc.ClientConn) {
-	addr := cfg.address()
-	if addr == "" {
-		return nil, nil
-	}
-
-	dialCtx, cancel := context.WithTimeout(context.Background(), cfg.dialTimeout())
-	defer cancel()
-
-	creds := credentials.NewTLS(&tls.Config{})
-	if cfg.InsecureTransport {
-		creds = insecure.NewCredentials()
-	}
-
-	conn, err := grpc.DialContext(dialCtx, addr, grpc.WithTransportCredentials(creds))
-	if err != nil {
-		i.logger.Warn("Failed to connect to fees service", zap.String("address", addr), zap.Error(err))
-		return nil, nil
-	}
-
-	i.logger.Info("Connected to fees service", zap.String("address", addr))
-	return feesv1.NewFeeEngineClient(conn), conn
-}
-
-func (i *Imp) initLedgerClient(cfg clientConfig) ledgerclient.Client {
-	addr := cfg.address()
-	if addr == "" {
-		return nil
-	}
-
-	ctx, cancel := context.WithTimeout(context.Background(), cfg.dialTimeout())
-	defer cancel()
-
-	client, err := ledgerclient.New(ctx, ledgerclient.Config{
-		Address:     addr,
-		DialTimeout: cfg.dialTimeout(),
-		CallTimeout: cfg.callTimeout(),
-		Insecure:    cfg.InsecureTransport,
-	})
-	if err != nil {
-		i.logger.Warn("Failed to connect to ledger service", zap.String("address", addr), zap.Error(err))
-		return nil
-	}
-	i.logger.Info("Connected to ledger service", zap.String("address", addr))
-	return client
-}
-
-func (i *Imp) initGatewayClient(cfg clientConfig) chainclient.Client {
-	addr := cfg.address()
-	if addr == "" {
-		return nil
-	}
-
-	ctx, cancel := context.WithTimeout(context.Background(), cfg.dialTimeout())
-	defer cancel()
-
-	client, err := chainclient.New(ctx, chainclient.Config{
-		Address:     addr,
-		DialTimeout: cfg.dialTimeout(),
-		CallTimeout: cfg.callTimeout(),
-		Insecure:    cfg.InsecureTransport,
-	})
-	if err != nil {
-		i.logger.Warn("failed to connect to chain gateway service", zap.String("address", addr), zap.Error(err))
-		return nil
-	}
-	i.logger.Info("connected to chain gateway service", zap.String("address", addr))
-	return client
-}
-
-func (i *Imp) initMntxClient(cfg clientConfig) mntxclient.Client {
-	addr := cfg.address()
-	if addr == "" {
-		return nil
-	}
-
-	ctx, cancel := context.WithTimeout(context.Background(), cfg.dialTimeout())
-	defer cancel()
-
-	client, err := mntxclient.New(ctx, mntxclient.Config{
-		Address:     addr,
-		DialTimeout: cfg.dialTimeout(),
-		CallTimeout: cfg.callTimeout(),
-		Logger:      i.logger.Named("client.mntx"),
-	})
-	if err != nil {
-		i.logger.Warn("Failed to connect to mntx gateway service", zap.String("address", addr), zap.Error(err))
-		return nil
-	}
-	i.logger.Info("Connected to mntx gateway service", zap.String("address", addr))
-	return client
-}
-
-func (i *Imp) initOracleClient(cfg clientConfig) oracleclient.Client {
-	addr := cfg.address()
-	if addr == "" {
-		return nil
-	}
-
-	ctx, cancel := context.WithTimeout(context.Background(), cfg.dialTimeout())
-	defer cancel()
-
-	client, err := oracleclient.New(ctx, oracleclient.Config{
-		Address:     addr,
-		DialTimeout: cfg.dialTimeout(),
-		CallTimeout: cfg.callTimeout(),
-		Insecure:    cfg.InsecureTransport,
-	})
-	if err != nil {
-		i.logger.Warn("Failed to connect to oracle service", zap.String("address", addr), zap.Error(err))
-		return nil
-	}
-	i.logger.Info("Connected to oracle service", zap.String("address", addr))
-	return client
-}
-
-func (i *Imp) loadConfig() (*config, error) {
-	data, err := os.ReadFile(i.file)
-	if err != nil {
-		i.logger.Error("Could not read configuration file", zap.String("config_file", i.file), zap.Error(err))
-		return nil, err
-	}
-
-	cfg := &config{Config: &grpcapp.Config{}}
-	if err := yaml.Unmarshal(data, cfg); err != nil {
-		i.logger.Error("Failed to parse configuration", zap.Error(err))
-		return nil, err
-	}
-
-	if cfg.Runtime == nil {
-		cfg.Runtime = &grpcapp.RuntimeConfig{ShutdownTimeoutSeconds: 15}
-	}
-
-	if cfg.GRPC == nil {
-		cfg.GRPC = &routers.GRPCConfig{
-			Network:          "tcp",
-			Address:          ":50062",
-			EnableReflection: true,
-			EnableHealth:     true,
-		}
-	} else {
-		if strings.TrimSpace(cfg.GRPC.Address) == "" {
-			cfg.GRPC.Address = ":50062"
-		}
-		if strings.TrimSpace(cfg.GRPC.Network) == "" {
-			cfg.GRPC.Network = "tcp"
-		}
-	}
-
-	if cfg.Metrics == nil {
-		cfg.Metrics = &grpcapp.MetricsConfig{Address: ":9403"}
-	} else if strings.TrimSpace(cfg.Metrics.Address) == "" {
-		cfg.Metrics.Address = ":9403"
-	}
-
-	return cfg, nil
-}
-
-func buildCardGatewayRoutes(src map[string]cardGatewayRouteConfig) map[string]orchestrator.CardGatewayRoute {
-	if len(src) == 0 {
-		return nil
-	}
-	result := make(map[string]orchestrator.CardGatewayRoute, len(src))
-	for key, route := range src {
-		trimmedKey := strings.TrimSpace(key)
-		if trimmedKey == "" {
-			continue
-		}
-		result[trimmedKey] = orchestrator.CardGatewayRoute{
-			FundingAddress: strings.TrimSpace(route.FundingAddress),
-			FeeAddress:     strings.TrimSpace(route.FeeAddress),
-			FeeWalletRef:   strings.TrimSpace(route.FeeWalletRef),
-		}
-	}
-	return result
-}
-
-func buildFeeLedgerAccounts(src map[string]string) map[string]string {
-	if len(src) == 0 {
-		return nil
-	}
-	result := make(map[string]string, len(src))
-	for key, account := range src {
-		k := strings.ToLower(strings.TrimSpace(key))
-		v := strings.TrimSpace(account)
-		if k == "" || v == "" {
-			continue
-		}
-		result[k] = v
-	}
-	return result
-}
-
-func buildGatewayRegistry(logger mlogger.Logger, mntxClient mntxclient.Client, src []gatewayInstanceConfig, registry *discovery.Registry) orchestrator.GatewayRegistry {
-	static := buildGatewayInstances(logger, src)
-	staticRegistry := orchestrator.NewGatewayRegistry(logger, mntxClient, static)
-	discoveryRegistry := orchestrator.NewDiscoveryGatewayRegistry(logger, registry)
-	return orchestrator.NewCompositeGatewayRegistry(logger, staticRegistry, discoveryRegistry)
-}
-
-func buildRailGateways(chainClient chainclient.Client, src []gatewayInstanceConfig) map[string]rail.RailGateway {
-	if chainClient == nil || len(src) == 0 {
-		return nil
-	}
-	instances := buildGatewayInstances(nil, src)
-	if len(instances) == 0 {
-		return nil
-	}
-	result := map[string]rail.RailGateway{}
-	for _, inst := range instances {
-		if inst == nil || !inst.IsEnabled {
-			continue
-		}
-		if inst.Rail != model.RailCrypto {
-			continue
-		}
-		cfg := chainclient.RailGatewayConfig{
-			Rail:    string(inst.Rail),
-			Network: inst.Network,
-			Capabilities: rail.RailCapabilities{
-				CanPayIn:               inst.Capabilities.CanPayIn,
-				CanPayOut:              inst.Capabilities.CanPayOut,
-				CanReadBalance:         inst.Capabilities.CanReadBalance,
-				CanSendFee:             inst.Capabilities.CanSendFee,
-				RequiresObserveConfirm: inst.Capabilities.RequiresObserveConfirm,
-			},
-		}
-		result[inst.ID] = chainclient.NewRailGateway(chainClient, cfg)
-	}
-	if len(result) == 0 {
-		return nil
-	}
-	return result
-}
-
-func buildGatewayInstances(logger mlogger.Logger, src []gatewayInstanceConfig) []*model.GatewayInstanceDescriptor {
-	if len(src) == 0 {
-		return nil
-	}
-	if logger != nil {
-		logger = logger.Named("gateway_instances")
-	}
-	result := make([]*model.GatewayInstanceDescriptor, 0, len(src))
-	for _, cfg := range src {
-		id := strings.TrimSpace(cfg.ID)
-		if id == "" {
-			if logger != nil {
-				logger.Warn("Gateway instance skipped: missing id")
-			}
-			continue
-		}
-		rail := parseRail(cfg.Rail)
-		if rail == model.RailUnspecified {
-			if logger != nil {
-				logger.Warn("Gateway instance skipped: invalid rail", zap.String("id", id), zap.String("rail", cfg.Rail))
-			}
-			continue
-		}
-		enabled := true
-		if cfg.IsEnabled != nil {
-			enabled = *cfg.IsEnabled
-		}
-		result = append(result, &model.GatewayInstanceDescriptor{
-			ID:         id,
-			Rail:       rail,
-			Network:    strings.ToUpper(strings.TrimSpace(cfg.Network)),
-			Currencies: normalizeCurrencies(cfg.Currencies),
-			Capabilities: model.RailCapabilities{
-				CanPayIn:               cfg.Capabilities.CanPayIn,
-				CanPayOut:              cfg.Capabilities.CanPayOut,
-				CanReadBalance:         cfg.Capabilities.CanReadBalance,
-				CanSendFee:             cfg.Capabilities.CanSendFee,
-				RequiresObserveConfirm: cfg.Capabilities.RequiresObserveConfirm,
-			},
-			Limits:    buildGatewayLimits(cfg.Limits),
-			Version:   strings.TrimSpace(cfg.Version),
-			IsEnabled: enabled,
-		})
-	}
-	return result
-}
-
-func parseRail(value string) model.Rail {
-	switch strings.ToUpper(strings.TrimSpace(value)) {
-	case string(model.RailCrypto):
-		return model.RailCrypto
-	case string(model.RailProviderSettlement):
-		return model.RailProviderSettlement
-	case string(model.RailLedger):
-		return model.RailLedger
-	case string(model.RailCardPayout):
-		return model.RailCardPayout
-	case string(model.RailFiatOnRamp):
-		return model.RailFiatOnRamp
-	default:
-		return model.RailUnspecified
-	}
-}
-
-func normalizeCurrencies(values []string) []string {
-	if len(values) == 0 {
-		return nil
-	}
-	seen := map[string]bool{}
-	result := make([]string, 0, len(values))
-	for _, value := range values {
-		clean := strings.ToUpper(strings.TrimSpace(value))
-		if clean == "" || seen[clean] {
-			continue
-		}
-		seen[clean] = true
-		result = append(result, clean)
-	}
-	return result
-}
-
-func buildGatewayLimits(cfg limitsConfig) model.Limits {
-	limits := model.Limits{
-		MinAmount:      strings.TrimSpace(cfg.MinAmount),
-		MaxAmount:      strings.TrimSpace(cfg.MaxAmount),
-		PerTxMaxFee:    strings.TrimSpace(cfg.PerTxMaxFee),
-		PerTxMinAmount: strings.TrimSpace(cfg.PerTxMinAmount),
-		PerTxMaxAmount: strings.TrimSpace(cfg.PerTxMaxAmount),
-	}
-
-	if len(cfg.VolumeLimit) > 0 {
-		limits.VolumeLimit = map[string]string{}
-		for key, value := range cfg.VolumeLimit {
-			bucket := strings.TrimSpace(key)
-			amount := strings.TrimSpace(value)
-			if bucket == "" || amount == "" {
-				continue
-			}
-			limits.VolumeLimit[bucket] = amount
-		}
-	}
-
-	if len(cfg.VelocityLimit) > 0 {
-		limits.VelocityLimit = map[string]int{}
-		for key, value := range cfg.VelocityLimit {
-			bucket := strings.TrimSpace(key)
-			if bucket == "" {
-				continue
-			}
-			limits.VelocityLimit[bucket] = value
-		}
-	}
-
-	if len(cfg.CurrencyLimits) > 0 {
-		limits.CurrencyLimits = map[string]model.LimitsOverride{}
-		for key, override := range cfg.CurrencyLimits {
-			currency := strings.ToUpper(strings.TrimSpace(key))
-			if currency == "" {
-				continue
-			}
-			limits.CurrencyLimits[currency] = model.LimitsOverride{
-				MaxVolume: strings.TrimSpace(override.MaxVolume),
-				MinAmount: strings.TrimSpace(override.MinAmount),
-				MaxAmount: strings.TrimSpace(override.MaxAmount),
-				MaxFee:    strings.TrimSpace(override.MaxFee),
-				MaxOps:    override.MaxOps,
-			}
-		}
-	}
-
-	return limits
-}

api/payments/orchestrator/internal/server/internal/types.go

@@ -0,0 +1,30 @@
+package serverimp
+
+import (
+	oracleclient "github.com/tech/sendico/fx/oracle/client"
+	chainclient "github.com/tech/sendico/gateway/chain/client"
+	mntxclient "github.com/tech/sendico/gateway/mntx/client"
+	ledgerclient "github.com/tech/sendico/ledger/client"
+	"github.com/tech/sendico/payments/orchestrator/storage"
+	"github.com/tech/sendico/pkg/discovery"
+	"github.com/tech/sendico/pkg/mlogger"
+	"github.com/tech/sendico/pkg/server/grpcapp"
+	"google.golang.org/grpc"
+)
+
+type Imp struct {
+	logger mlogger.Logger
+	file   string
+	debug  bool
+
+	config             *config
+	app                *grpcapp.App[storage.Repository]
+	discoveryWatcher   *discovery.RegistryWatcher
+	discoveryReg       *discovery.Registry
+	discoveryAnnouncer *discovery.Announcer
+	feesConn           *grpc.ClientConn
+	ledgerClient       ledgerclient.Client
+	gatewayClient      chainclient.Client
+	mntxClient         mntxclient.Client
+	oracleClient       oracleclient.Client
+}

api/payments/orchestrator/internal/service/orchestrator/discovery_gateway_registry.go

@@ -45,6 +45,7 @@ func (r *discoveryGatewayRegistry) List(_ context.Context) ([]*model.GatewayInst
 		}
 		items = append(items, &model.GatewayInstanceDescriptor{
 			ID:           entry.ID,
+			InstanceID:   entry.InstanceID,
 			Rail:         rail,
 			Network:      entry.Network,
 			Currencies:   normalizeCurrencies(entry.Currencies),

api/payments/orchestrator/storage/model/payment.go

@@ -113,6 +113,7 @@ type Limits struct {
 // GatewayInstanceDescriptor standardizes gateway instance self-declaration.
 type GatewayInstanceDescriptor struct {
 	ID           string           `bson:"id" json:"id"`
+	InstanceID   string           `bson:"instanceId,omitempty" json:"instanceId,omitempty"`
 	Rail         Rail             `bson:"rail" json:"rail"`
 	Network      string           `bson:"network,omitempty" json:"network,omitempty"`
 	Currencies   []string         `bson:"currencies,omitempty" json:"currencies,omitempty"`