popov/gogo2
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

mexc interface integrations REST API fixes

Browse Source
This commit is contained in:
Dobromir Popov
2025-07-14 11:15:11 +03:00
parent e74f1393c4
commit d42c9ada8c
11 changed files with 4120 additions and 174 deletions
Download Patch File Download Diff File Expand all files Collapse all files

153
NN/exchanges/mexc_interface.py
View File

@ -65,45 +65,48 @@ class MEXCInterface(ExchangeInterface):
return False
def _format_spot_symbol(self, symbol: str) -> str:
"""Formats a symbol to MEXC spot API standard (e.g., 'ETH/USDT' -> 'ETHUSDC')."""
"""Formats a symbol to MEXC spot API standard and converts USDT to USDC for execution."""
if '/' in symbol:
base, quote = symbol.split('/')
# Convert USDT to USDC for MEXC spot trading
# Convert USDT to USDC for MEXC execution (MEXC API only supports USDC pairs)
if quote.upper() == 'USDT':
quote = 'USDC'
return f"{base.upper()}{quote.upper()}"
else:
# Convert USDT to USDC for symbols like ETHUSDT
symbol = symbol.upper()
if symbol.endswith('USDT'):
symbol = symbol.replace('USDT', 'USDC')
return symbol
# Convert USDT to USDC for symbols like ETHUSDT -> ETHUSDC
if symbol.upper().endswith('USDT'):
symbol = symbol.upper().replace('USDT', 'USDC')
return symbol.upper()
def _format_futures_symbol(self, symbol: str) -> str:
"""Formats a symbol to MEXC futures API standard (e.g., 'ETH/USDT' -> 'ETH_USDT')."""
# This method is included for completeness but should not be used for spot trading
return symbol.replace('/', '_').upper()
def _generate_signature(self, timestamp: str, method: str, endpoint: str, params: Dict[str, Any]) -> str:
"""Generate signature for private API calls using MEXC's expected parameter order"""
# MEXC requires specific parameter ordering, not alphabetical
# Based on successful test: symbol, side, type, quantity, timestamp, then other params
mexc_param_order = ['symbol', 'side', 'type', 'quantity', 'timestamp', 'recvWindow']
def _generate_signature(self, params: Dict[str, Any]) -> str:
"""Generate signature for private API calls using MEXC's parameter ordering"""
# MEXC uses specific parameter ordering for signature generation
# Based on working Postman collection: symbol, side, type, quantity, price, timestamp, recvWindow, then others
# Remove signature if present
clean_params = {k: v for k, v in params.items() if k != 'signature'}
# MEXC parameter order (from working Postman collection)
mexc_order = ['symbol', 'side', 'type', 'quantity', 'price', 'timestamp', 'recvWindow']
# Build ordered parameter list
ordered_params = []
# Add parameters in MEXC's expected order
for param_name in mexc_param_order:
if param_name in params and param_name != 'signature':
ordered_params.append(f"{param_name}={params[param_name]}")
for param_name in mexc_order:
if param_name in clean_params:
ordered_params.append(f"{param_name}={clean_params[param_name]}")
del clean_params[param_name]
# Add any remaining parameters not in the standard order (alphabetically)
remaining_params = {k: v for k, v in params.items() if k not in mexc_param_order and k != 'signature'}
for key in sorted(remaining_params.keys()):
ordered_params.append(f"{key}={remaining_params[key]}")
# Add any remaining parameters in alphabetical order
for key in sorted(clean_params.keys()):
ordered_params.append(f"{key}={clean_params[key]}")
# Create query string (MEXC doesn't use the api_key + timestamp prefix)
# Create query string
query_string = '&'.join(ordered_params)
logger.debug(f"MEXC signature query string: {query_string}")
@ -118,7 +121,7 @@ class MEXCInterface(ExchangeInterface):
logger.debug(f"MEXC signature: {signature}")
return signature
def _send_public_request(self, method: str, endpoint: str, params: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
def _send_public_request(self, method: str, endpoint: str, params: Optional[Dict[str, Any]] = None) -> Any:
"""Send a public API request to MEXC."""
if params is None:
params = {}
@ -145,46 +148,52 @@ class MEXCInterface(ExchangeInterface):
logger.error(f"Error in public request to {endpoint}: {e}")
return {}
def _send_private_request(self, method: str, endpoint: str, params: Dict[str, Any] = None) -> Optional[Dict[str, Any]]:
def _send_private_request(self, method: str, endpoint: str, params: Optional[Dict[str, Any]] = None) -> Optional[Dict[str, Any]]:
"""Send a private request to the exchange with proper signature"""
if params is None:
params = {}
timestamp = str(int(time.time() * 1000))
# Add timestamp and recvWindow to params for signature and request
params['timestamp'] = timestamp
params['recvWindow'] = self.recv_window
signature = self._generate_signature(timestamp, method, endpoint, params)
params['recvWindow'] = str(self.recv_window)
# Generate signature with all parameters
signature = self._generate_signature(params)
params['signature'] = signature
headers = {
"X-MEXC-APIKEY": self.api_key,
"Request-Time": timestamp
"X-MEXC-APIKEY": self.api_key
}
# For spot API, use the correct endpoint format
if not endpoint.startswith('api/v3/'):
endpoint = f"api/v3/{endpoint}"
url = f"{self.base_url}/{endpoint}"
try:
if method.upper() == "GET":
response = self.session.get(url, headers=headers, params=params, timeout=10)
elif method.upper() == "POST":
# MEXC expects POST parameters as query string, not in body
# For POST requests, MEXC expects parameters as query parameters, not form data
# Based on Postman collection: Content-Type header is disabled
response = self.session.post(url, headers=headers, params=params, timeout=10)
elif method.upper() == "DELETE":
response = self.session.delete(url, headers=headers, params=params, timeout=10)
else:
logger.error(f"Unsupported method: {method}")
return None
response.raise_for_status()
data = response.json()
# For successful responses, return the data directly
# MEXC doesn't always use 'success' field for successful operations
logger.debug(f"Request URL: {response.url}")
logger.debug(f"Response status: {response.status_code}")
if response.status_code == 200:
return data
return response.json()
else:
logger.error(f"API error: Status Code: {response.status_code}, Response: {response.text}")
return None
except requests.exceptions.HTTPError as http_err:
logger.error(f"HTTP error for {endpoint}: Status Code: {response.status_code}, Response: {response.text}")
logger.error(f"HTTP error details: {http_err}")
@ -223,7 +232,11 @@ class MEXCInterface(ExchangeInterface):
ticker_data = response
elif isinstance(response, list) and len(response) > 0:
# If the response is a list, try to find the specific symbol
found_ticker = next((item for item in response if item.get('symbol') == formatted_symbol), None)
found_ticker = None
for item in response:
if isinstance(item, dict) and item.get('symbol') == formatted_symbol:
found_ticker = item
break
if found_ticker:
ticker_data = found_ticker
else:
@ -293,38 +306,66 @@ class MEXCInterface(ExchangeInterface):
logger.info(f"Supported symbols include: {supported_symbols[:10]}...") # Show first 10
return {}
endpoint = "order"
# Round quantity to MEXC precision requirements and ensure minimum order value
# MEXC ETHUSDC requires precision based on baseAssetPrecision (5 decimals for ETH)
if 'ETH' in formatted_symbol:
quantity = round(quantity, 5) # MEXC ETHUSDC precision: 5 decimals
# Ensure minimum order value (typically $10+ for MEXC)
if price and quantity * price < 10.0:
quantity = round(10.0 / price, 5) # Adjust to minimum $10 order
elif 'BTC' in formatted_symbol:
quantity = round(quantity, 6) # MEXC BTCUSDC precision: 6 decimals
if price and quantity * price < 10.0:
quantity = round(10.0 / price, 6) # Adjust to minimum $10 order
else:
quantity = round(quantity, 5) # Default precision for MEXC
if price and quantity * price < 10.0:
quantity = round(10.0 / price, 5) # Adjust to minimum $10 order
params: Dict[str, Any] = {
# MEXC doesn't support MARKET orders for many pairs - use LIMIT orders instead
if order_type.upper() == 'MARKET':
# Convert market order to limit order with aggressive pricing for immediate execution
if price is None:
ticker = self.get_ticker(symbol)
if ticker and 'last' in ticker:
current_price = float(ticker['last'])
# For buy orders, use slightly above market to ensure immediate execution
# For sell orders, use slightly below market to ensure immediate execution
if side.upper() == 'BUY':
price = current_price * 1.002 # 0.2% premium for immediate buy execution
else:
price = current_price * 0.998 # 0.2% discount for immediate sell execution
else:
logger.error("Cannot get current price for market order conversion")
return {}
# Convert to limit order with immediate execution pricing
order_type = 'LIMIT'
logger.info(f"MEXC: Converting MARKET to aggressive LIMIT order at ${price:.2f} for immediate execution")
# Prepare order parameters
params = {
'symbol': formatted_symbol,
'side': side.upper(),
'type': order_type.upper(),
'quantity': str(quantity) # Quantity must be a string
}
if price is not None:
params['price'] = str(price) # Price must be a string for limit orders
# Format price to remove unnecessary decimal places (e.g., 2900.0 -> 2900)
params['price'] = str(int(price)) if price == int(price) else str(price)
logger.info(f"MEXC: Placing {side.upper()} {order_type.upper()} order for {quantity} {formatted_symbol} at price {price}")
# For market orders, some parameters might be optional or handled differently.
# Check MEXC API docs for market order specifics (e.g., quoteOrderQty for buy market orders)
if order_type.upper() == 'MARKET' and side.upper() == 'BUY':
# If it's a market buy order, MEXC often expects quoteOrderQty instead of quantity
# Assuming quantity here refers to the base asset, if quoteOrderQty is needed, adjust.
# For now, we will stick to quantity and let MEXC handle the conversion if possible
pass # No specific change needed based on the current params structure
try:
# MEXC API endpoint for placing orders is /api/v3/order (POST)
order_result = self._send_private_request('POST', endpoint, params)
if order_result:
logger.info(f"MEXC: Order placed successfully: {order_result}")
return order_result
else:
logger.error(f"MEXC: Error placing order: {order_result}")
return {}
except Exception as e:
logger.error(f"MEXC: Exception placing order: {e}")
# Use the standard private request method which handles timestamp and signature
endpoint = "order"
result = self._send_private_request("POST", endpoint, params)
if result:
logger.info(f"MEXC: Order placed successfully: {result}")
return result
else:
logger.error(f"MEXC: Failed to place order")
return {}
def cancel_order(self, symbol: str, order_id: str) -> Dict[str, Any]: