feat / Use network as connector_name for Gateway executors

models/executors.py

@@ -213,7 +213,7 @@ class PositionsSummaryResponse(BaseModel):
     "twap_executor",
     "xemm_executor",
     "order_executor",
-    "lp_executor"
+    "lp_executor",
 ]
 
 
@@ -248,21 +248,20 @@ class CreateExecutorRequest(BaseModel):
                 },
                 {
                     "summary": "LP Executor",
-                    "description": "Create an LP position on a CLMM DEX (Meteora, Raydium)",
+                    "description": "Create an LP position on a CLMM DEX",
                     "value": {
                         "account_name": "master_account",
                         "executor_config": {
                             "type": "lp_executor",
-                            "connector_name": "meteora/clmm",
+                            "connector_name": "solana-mainnet-beta",
+                            "lp_provider": "meteora/clmm",
                             "trading_pair": "SOL-USDC",
                             "pool_address": "HTvjzsfX3yU6BUodCjZ5vZkUrAxMDTrBs3CJaq43ashR",
                             "lower_price": "80",
                             "upper_price": "100",
                             "base_amount": "0",
                             "quote_amount": "10.0",
-                            "side": 1,
-                            "auto_close_above_range_seconds": None,
-                            "auto_close_below_range_seconds": 300,
+                            "side": "BUY",
                             "extra_params": {"strategyType": 0},
                             "keep_position": False
                         }

routers/connectors.py

@@ -16,9 +16,11 @@ async def available_connectors():
     Get a list of all available connectors.
 
     Returns:
-        List of connector names supported by the system
+        List of connector names supported by the system (excludes DEX providers which use Gateway networks)
     """
-    return list(AllConnectorSettings.get_connector_settings().keys())
+    all_connectors = AllConnectorSettings.get_connector_settings().keys()
+    # Filter out DEX providers (contain '/') - these are accessed via Gateway networks
+    return [c for c in all_connectors if '/' not in c]
 
 
 @router.get("/{connector_name}/config-map", response_model=Dict[str, dict])

routers/gateway.py

@@ -606,9 +606,7 @@ async def add_network_token(
 
         return {
             "success": True,
-            "message": f"Token {token_request.symbol} added to {network_id}. Restart Gateway for changes to take effect.",
-            "restart_required": True,
-            "restart_endpoint": "POST /gateway/restart",
+            "message": f"Token {token_request.symbol} added to {network_id}.",
             "token": {
                 "symbol": token_request.symbol,
                 "address": token_request.address,
@@ -661,9 +659,7 @@ async def delete_network_token(
 
         return {
             "success": True,
-            "message": f"Token {token_address} deleted from {network_id}. Restart Gateway for changes to take effect.",
-            "restart_required": True,
-            "restart_endpoint": "POST /gateway/restart",
+            "message": f"Token {token_address} deleted from {network_id}.",
             "token_address": token_address,
             "network_id": network_id
         }

services/accounts_service.py

@@ -438,16 +438,12 @@ class AccountsService:
     update the balances of each account.
     """
     default_quotes = {
-        "hyperliquid": "USD",
-        "hyperliquid_perpetual": "USDC",
+        "hyperliquid": "USDC",
+        "hyperliquid_perpetual": "USD",
         "xrpl": "RLUSD",
         "kraken": "USD",
     }
-    gateway_default_pricing_connector = {
-        "ethereum": "uniswap/router",
-        "solana": "jupiter/router",
-    }
-    potential_wrapped_tokens = ["ETH", "SOL", "BNB", "POL", "AVAX", "FTM", "ONE", "GLMR", "MOVR"]
+    potential_wrapped_tokens = ["ETH", "SOL", "BNB", "POL", "AVAX"]
 
     # Cache for storing last successful prices by trading pair
     _last_known_prices = {}
@@ -2164,10 +2160,6 @@ async def _fetch_gateway_prices_immediate(self, chain: str, network: str,
         Fetch prices immediately from Gateway for the given tokens.
         This is used to get prices right away instead of waiting for the background update task.
 
-        Uses the same pricing connector resolution as MarketDataProvider.update_rates_task():
-        - solana -> jupiter/router
-        - ethereum -> uniswap/router
-
         Args:
             chain: Blockchain chain (e.g., 'solana', 'ethereum')
             network: Network name (e.g., 'mainnet-beta', 'mainnet')
@@ -2184,11 +2176,8 @@ async def _fetch_gateway_prices_immediate(self, chain: str, network: str,
         rate_oracle = RateOracle.get_instance()
         prices = {}
 
-        # Resolve pricing connector based on chain (same logic as MarketDataProvider)
-        pricing_connector = self.gateway_default_pricing_connector.get(chain)
-        if not pricing_connector:
-            logger.warning(f"No pricing connector configured for chain '{chain}', skipping immediate price fetch")
-            return prices
+        # Construct full network name (e.g., "solana-mainnet-beta")
+        full_network = f"{chain}-{network}"
 
         # Create tasks for all tokens in parallel
         tasks = []
@@ -2222,10 +2211,9 @@ async def _fetch_gateway_prices_immediate(self, chain: str, network: str,
                 continue
 
             try:
+                # get_price will auto-fetch dex/trading_type from network's swap provider
                 task = gateway_client.get_price(
-                    chain=chain,
-                    network=network,
-                    connector=pricing_connector,
+                    network=full_network,
                     base_asset=token,
                     quote_asset=quote_asset,
                     amount=Decimal("1"),

services/executor_service.py

@@ -352,13 +352,13 @@ async def create_executor(
         # Extract connector and trading pair from config
         connector_name = executor_config.get("connector_name")
         trading_pair = executor_config.get("trading_pair")
-        if not connector_name:
-            raise HTTPException(status_code=400, detail="connector_name is required in executor_config")
-        if not trading_pair:
-            raise HTTPException(status_code=400, detail="trading_pair is required in executor_config")
 
         # Ensure connector and market are ready
-        await trading_interface.add_market(connector_name, trading_pair)
+        if connector_name:
+            if trading_pair:
+                await trading_interface.add_market(connector_name, trading_pair)
+            else:
+                await trading_interface.ensure_connector(connector_name)
 
         # Set timestamp if not provided (required for time-based features like time_limit)
         if "timestamp" not in executor_config or executor_config["timestamp"] is None:
@@ -650,6 +650,12 @@ def _format_executor_info(
         result["close_type"] = executor.close_type.name if executor.close_type else None
         result["is_active"] = not executor.is_closed
 
+        # Add side from executor_info (it's a property, not serialized by model_dump)
+        side = executor_info.side
+        if side is not None:
+            # Convert TradeType enum or int to string
+            result["side"] = side.name if hasattr(side, 'name') else str(side)
+
         # For grid executors, filter out heavy fields from custom_info
         if executor_type == "grid_executor" and result.get("custom_info"):
             heavy_fields = {"levels_by_state", "filled_orders", "failed_orders", "canceled_orders"}

services/gateway_client.py

@@ -1,5 +1,4 @@
 import logging
-from decimal import Decimal
 from typing import Dict, List, Optional
 
 import aiohttp
@@ -582,20 +581,19 @@ async def poll_transaction(
         self,
         network_id: str,
         tx_hash: str,
-        wallet_address: Optional[str] = None
     ) -> Optional[Dict]:
         """
         Poll transaction status on blockchain.
 
         Args:
             network_id: Network ID in format 'chain-network' (e.g., 'solana-mainnet-beta', 'ethereum-mainnet')
             tx_hash: Transaction hash/signature
-            wallet_address: Optional wallet address for verification
 
         Returns:
             Transaction status dict with fields:
-            - txStatus: 1 for confirmed, 0 for failed/pending
+            - txStatus: 1 for confirmed, 0 for pending, -1 for failed
             - fee: Transaction fee amount
+            - error: Parsed error message if transaction failed (e.g., "SLIPPAGE_EXCEEDED (0x1771): ...")
             - txData: Full transaction data including meta.err
             Returns None if Gateway is unavailable or request fails.
         """
@@ -612,11 +610,8 @@ async def poll_transaction(
                 "network": network,
                 "signature": tx_hash
             }
-            if wallet_address:
-                payload["walletAddress"] = wallet_address
 
             return await self._request("POST", f"chains/{chain}/poll", json=payload)
         except Exception as e:
             logger.error(f"Error polling transaction {tx_hash}: {e}")
             return None
-

services/gateway_transaction_poller.py

@@ -8,16 +8,16 @@
 """
 import asyncio
 import logging
-from typing import Optional, Dict, List
 from datetime import datetime, timedelta, timezone
 from decimal import Decimal
+from typing import Dict, List, Optional
 
 from sqlalchemy import select
 from sqlalchemy.orm import selectinload
 
 from database import AsyncDatabaseManager
-from database.repositories import GatewaySwapRepository, GatewayCLMMRepository
 from database.models import GatewayCLMMEvent, GatewayCLMMPosition
+from database.repositories import GatewayCLMMRepository, GatewaySwapRepository
 from services.gateway_client import GatewayClient
 
 logger = logging.getLogger(__name__)
@@ -312,9 +312,6 @@ async def _check_transaction_status(
 
             # Parse the response with defensive checks
             tx_status = result.get("txStatus")
-            tx_data = result.get("txData") or {}
-            meta = tx_data.get("meta") if isinstance(tx_data, dict) else {}
-            error = meta.get("err") if isinstance(meta, dict) else None
 
             # Determine gas token based on chain
             gas_token = {
@@ -326,18 +323,25 @@ async def _check_transaction_status(
                 "avalanche": "AVAX"
             }.get(chain, "UNKNOWN")
 
-            # Transaction is confirmed if txStatus == 1 and no error
-            if tx_status == 1 and error is None:
+            # Transaction is confirmed if txStatus == 1
+            if tx_status == 1:
                 return {
                     "status": "CONFIRMED",
                     "gas_fee": result.get("fee", 0),
                     "gas_token": gas_token,
                     "error_message": None
                 }
 
-            # Transaction failed if there's an error
-            if error is not None:
-                error_msg = str(error) if error else "Transaction failed on-chain"
+            # Transaction failed if txStatus == -1 or there's an error field
+            # Gateway now returns parsed error messages like "SLIPPAGE_EXCEEDED (0x1771): ..."
+            error_msg = result.get("error")
+            if tx_status == -1 or error_msg:
+                if not error_msg:
+                    # Fallback to meta.err if no parsed error
+                    tx_data = result.get("txData") or {}
+                    meta = tx_data.get("meta") if isinstance(tx_data, dict) else {}
+                    raw_error = meta.get("err") if isinstance(meta, dict) else None
+                    error_msg = str(raw_error) if raw_error else "Transaction failed on-chain"
                 return {
                     "status": "FAILED",
                     "gas_fee": result.get("fee", 0),
@@ -352,14 +356,13 @@ async def _check_transaction_status(
             logger.error(f"Error checking transaction status for {tx_hash}: {e}")
             return None
 
-    async def poll_transaction_once(self, tx_hash: str, network_id: str, wallet_address: Optional[str] = None) -> Optional[Dict]:
+    async def poll_transaction_once(self, tx_hash: str, network_id: str) -> Optional[Dict]:
         """
         Poll a specific transaction once (useful for immediate status checks).
 
         Args:
             tx_hash: Transaction hash
             network_id: Network ID in format 'chain-network' (e.g., 'solana-mainnet-beta')
-            wallet_address: Optional wallet address for verification
 
         Returns:
             Transaction status dict or None if pending

services/trading_service.py

@@ -7,14 +7,14 @@
 import logging
 import time
 from decimal import Decimal
-from typing import Dict, List, Optional, Set, TYPE_CHECKING
+from typing import TYPE_CHECKING, Dict, List, Optional, Set
 
 from hummingbot.connector.connector_base import ConnectorBase
-from hummingbot.core.data_type.common import OrderType, TradeType, PositionAction
+from hummingbot.core.data_type.common import OrderType, PositionAction, TradeType
 
 if TYPE_CHECKING:
-    from services.unified_connector_service import UnifiedConnectorService
     from services.market_data_service import MarketDataService
+    from services.unified_connector_service import UnifiedConnectorService
 
 
 logger = logging.getLogger(__name__)
@@ -173,6 +173,14 @@ async def add_market(
         # Register trading pair with connector
         self._register_trading_pair_with_connector(connector, trading_pair)
 
+        # Update balances to include tokens from new trading pair
+        if hasattr(connector, '_update_balances'):
+            try:
+                await connector._update_balances()
+                logger.debug(f"Updated balances for {connector_name} after adding {trading_pair}")
+            except Exception as e:
+                logger.warning(f"Failed to update balances for {connector_name}: {e}")
+
         logger.info(f"Market {connector_name}/{trading_pair} added to trading interface")
 
     async def remove_market(

services/unified_connector_service.py

@@ -22,7 +22,7 @@
 from hummingbot.connector.connector_base import ConnectorBase
 from hummingbot.connector.connector_metrics_collector import TradeVolumeMetricCollector
 from hummingbot.connector.exchange_py_base import ExchangePyBase
-from hummingbot.connector.gateway.gateway_lp import GatewayLp
+from hummingbot.connector.gateway.gateway import Gateway
 from hummingbot.connector.perpetual_derivative_py_base import PerpetualDerivativePyBase
 from hummingbot.core.data_type.common import OrderType, PositionAction, PositionMode, TradeType
 from hummingbot.core.data_type.in_flight_order import InFlightOrder, OrderState
@@ -635,21 +635,21 @@ def _create_trading_connector(
     ) -> ConnectorBase:
         """Create a trading connector with API keys.
 
-        For gateway connectors (containing '/'), creates a GatewayLp connector
-        which auto-detects chain/network and uses the default wallet.
+        For Gateway network connectors (e.g., 'solana-mainnet-beta'), creates a unified
+        Gateway connector which auto-detects chain/network and uses the default wallet.
+        The dex_name and trading_type are passed to methods, not to the connector.
         """
         BackendAPISecurity.login_account(
             account_name=account_name,
             secrets_manager=self.secrets_manager
         )
 
-        # Gateway connectors (e.g., 'meteora/clmm', 'raydium/clmm') are not in AllConnectorSettings
-        # They use GatewayLp which auto-detects chain/network from gateway config
-        if '/' in connector_name:
-            logger.info(f"Creating gateway connector: {connector_name}")
-            # GatewayLp handles chain/network auto-detection and default wallet lookup
-            # via start_network() call
-            return GatewayLp(
+        # Check if this is a Gateway network connector
+        # Gateway connectors are NOT in AllConnectorSettings (those are exchange connectors)
+        # Network format: "chain-network" (e.g., "solana-mainnet-beta", "ethereum-mainnet")
+        if connector_name not in self._conn_settings:
+            logger.info(f"Creating Gateway connector for network: {connector_name}")
+            return Gateway(
                 connector_name=connector_name,
                 trading_pairs=[],
                 trading_required=True,