# -*- coding: utf-8 -*- from ccxt.async_support.mt5 import mt5 as mt5Parent from ccxt.base.errors import ExchangeError, ArgumentsRequired from ccxt.async_support.base.ws.client import Client import asyncio from typing import Optional, Dict, Any, List import urllib.parse class mt5(mt5Parent): def describe(self): return self.deep_extend(super(mt5, self).describe(), { 'has': { 'ws': True, 'watchBalance': True, 'watchOrders': True, 'watchPositions': True, 'watchTicker': True, 'watchOHLCV': True, 'watchAll': True, }, 'urls': { 'api': { 'ws': 'ws://{hostname}', }, }, 'options': { 'tradesLimit': 1000, 'ordersLimit': 1000, 'OHLCVLimit': 1000, 'positionsLimit': 1000, }, 'streaming': { 'ping': True, 'maxPingPongMisses': 2, }, }) async def watch_all(self, params={}): """监听所有数据（订单、持仓、钱包）""" if not hasattr(self, 'token') or not self.token: await self.get_token() # 检查连接状态 try: await self.check_connect() except Exception as e: if self.verbose: print(f"连接检查失败，重新连接: {e}") await self.get_token() ws_url = self.implode_hostname(self.urls['api']['ws']) url = ws_url + '/OnOrderUpdate?id=' + self.token message_hash = 'all_data' return await self.watch(url, message_hash) async def watch_balance(self, params={}): """监听余额变化""" if not hasattr(self, 'token') or not self.token: await self.get_token() ws_url = self.implode_hostname(self.urls['api']['ws']) url = ws_url + '/OnOrderUpdate?id=' + self.token message_hash = 'balance' return await self.watch(url, message_hash) async def watch_orders(self, symbol: Optional[str] = None, since: Optional[int] = None, limit: int = 1, params={}): """监听订单变化""" if not hasattr(self, 'token') or not self.token: await self.get_token() await self.server_timezone() ws_url = self.implode_hostname(self.urls['api']['ws']) url = ws_url + '/OnOrderUpdate?id=' + self.token message_hash = 'orders' if symbol is not None: symbol = self.symbol(symbol) message_hash += ':' + symbol orders = await self.watch(url, message_hash) # 过滤订单 if symbol is not None: orders = [order for order in orders if order['symbol'] == symbol] if since is not None: orders = [order for order in orders if order['timestamp'] >= since] # 限制返回数量 if limit is not None: orders = orders[-limit:] return orders async def watch_positions(self, symbols: Optional[List[str]] = None, since: Optional[int] = None, limit: Optional[int] = None, params={}): """监听持仓变化""" if not hasattr(self, 'token') or not self.token: await self.get_token() await self.server_timezone() ws_url = self.implode_hostname(self.urls['api']['ws']) url = ws_url + '/OnOrderUpdate?id=' + self.token message_hash = 'positions' if symbols is not None: symbols = [self.symbol(symbol) for symbol in symbols] message_hash += ':' + ':'.join(symbols) positions = await self.watch(url, message_hash) # 过滤持仓 if symbols is not None: positions = [position for position in positions if position['symbol'] in symbols] if since is not None: positions = [position for position in positions if position['timestamp'] >= since] if limit is not None: positions = positions[-limit:] return positions async def watch_ticker(self, symbol: str, params={}): await self.load_markets() market = self.market(symbol) if not hasattr(self, 'token') or not self.token: await self.get_token() # WebSocket 监听地址 ws_url = self.implode_hostname(self.urls['api']['ws']) url = ws_url + '/OnQuote?id=' + self.token # 订阅参数 request = { 'id': self.token, 'symbol': market['id'], } # 消息哈希 message_hash = 'ticker:' + market['symbol'] # 订阅哈希（用于管理订阅状态） subscribe_hash = 'ticker:' + market['id'] try: # 检查是否已经订阅 if not hasattr(self, 'ticker_subscriptions'): self.ticker_subscriptions = set() # 如果尚未订阅，发送订阅请求 if subscribe_hash not in self.ticker_subscriptions: subscription_result = await self.send_ticker_subscription(request, params) if not subscription_result: raise ExchangeError("行情订阅失败") # 记录订阅状态 self.ticker_subscriptions.add(subscribe_hash) if self.verbose: print(f"✅ 行情订阅成功: {symbol}") # 监听 WebSocket 数据 ticker = await self.watch(url, message_hash, subscribe_hash=subscribe_hash) return ticker except Exception as e: if self.verbose: print(f"❌ 行情监听失败: {e}") raise e async def watch_ohlcv(self, symbol: str, timeframe='1m', since: Optional[int] = None, limit: Optional[int] = None, params={}): await self.load_markets() market = self.market(symbol) if not hasattr(self, 'token') or not self.token: await self.get_token() # WebSocket 监听地址 ws_url = self.implode_hostname(self.urls['api']['ws']) url = ws_url + '/OnOhlc?id=' + self.token # 订阅参数 request = { 'id': self.token, 'symbol': market['id'], 'timeframe': self.timeframes[timeframe], } # 消息哈希 message_hash = 'ohlcv:' + market['symbol'] + ':' + timeframe # 订阅哈希（用于管理订阅状态） subscribe_hash = 'ohlcv:' + market['id'] + ':' + str(self.timeframes[timeframe]) try: # 检查是否已经订阅 if not hasattr(self, 'ohlcv_subscriptions'): self.ohlcv_subscriptions = set() # 如果尚未订阅，发送订阅请求 if subscribe_hash not in self.ohlcv_subscriptions: subscription_result = await self.send_ohlcv_subscription(request, params) if not subscription_result: raise ExchangeError("K线订阅失败") # 记录订阅状态 self.ohlcv_subscriptions.add(subscribe_hash) if self.verbose: print(f"✅ K线订阅成功: {symbol} {timeframe}") # 监听 WebSocket 数据 ohlcv = await self.watch(url, message_hash, subscribe_hash=subscribe_hash) return self.filter_by_since_limit(ohlcv, since, limit, 0, True) except Exception as e: if self.verbose: print(f"❌ K线监听失败: {e}") raise e async def close_ticker(self, symbol: str, params={}): """取消行情订阅""" await self.load_markets() market = self.market(symbol) if not hasattr(self, 'token') or not self.token: await self.get_token() # 取消订阅参数 request = { 'id': self.token, 'symbol': market['id'], } try: # 发送取消订阅请求 result = await self.private_get('UnSubscribe', self.extend(request, params)) # 更新订阅状态 if hasattr(self, 'ticker_subscriptions'): subscribe_hash = 'ticker:' + market['id'] if subscribe_hash in self.ticker_subscriptions: self.ticker_subscriptions.remove(subscribe_hash) if self.verbose: print(f"✅ 取消行情订阅成功: {symbol}") return result except Exception as e: if self.verbose: print(f"❌ 取消行情订阅失败: {e}") raise e async def close_ohlcv(self, symbol: Optional[str] = None, timeframe: Optional[str] = None, params={}): """取消K线订阅""" if not hasattr(self, 'token') or not self.token: await self.get_token() # 取消订阅参数 request = { 'id': self.token, } # 如果指定了交易对，添加到参数中 if symbol is not None: await self.load_markets() market = self.market(symbol) request['symbol'] = market['id'] try: # 发送取消订阅请求 result = await self.private_get('UnsubscribeOhlc', self.extend(request, params)) # 更新订阅状态 if hasattr(self, 'ohlcv_subscriptions'): if symbol is not None: # 取消指定交易对的所有时间帧订阅 if timeframe is not None: # 取消指定交易对和指定时间帧的订阅 subscribe_hash = 'ohlcv:' + market['id'] + ':' + str(self.timeframes[timeframe]) if subscribe_hash in self.ohlcv_subscriptions: self.ohlcv_subscriptions.remove(subscribe_hash) else: # 取消指定交易对的所有时间帧订阅 to_remove = [h for h in self.ohlcv_subscriptions if h.startswith('ohlcv:' + market['id'] + ':')] for hash_to_remove in to_remove: self.ohlcv_subscriptions.remove(hash_to_remove) else: # 取消所有K线订阅 self.ohlcv_subscriptions.clear() if self.verbose: if symbol is not None: if timeframe is not None: print(f"✅ 取消K线订阅成功: {symbol} {timeframe}") else: print(f"✅ 取消K线订阅成功: {symbol} (所有时间帧)") else: print(f"✅ 取消所有K线订阅成功") return result except Exception as e: if self.verbose: print(f"❌ 取消K线订阅失败: {e}") raise e async def close(self): """关闭所有连接和清理缓存""" try: # 取消所有订阅 if hasattr(self, 'ohlcv_subscriptions') and self.ohlcv_subscriptions: await self.close_ohlcv() if hasattr(self, 'ticker_subscriptions') and self.ticker_subscriptions: # 取消所有ticker订阅 for subscribe_hash in list(self.ticker_subscriptions): symbol = subscribe_hash.replace('ticker:', '') try: await self.close_ticker(symbol) except Exception: pass # 清理缓存 self.orders_list = [] self.positions_list = [] self.ohlcv_cache = {} self.ticker_cache = {} # 断开连接 await self.disconnect() except Exception as e: if self.verbose: print(f"关闭连接时出错: {e}") await super().close() def handle_message(self, client: Client, message): """处理WebSocket消息 - 根据类型分发""" try: # 检查错误 error_code = self.safe_string(message, 'errorCode') if error_code is not None and error_code != '0': self.handle_error_message(client, message) return # 解析消息类型 message_type = self.safe_string(message, 'type') if message_type == 'OrderUpdate': self.handle_order_update_message(client, message) elif message_type == 'OpenedOrders': self.handle_opened_orders_message(client, message) elif message_type == 'Ohlc': self.handle_ohlc_message(client, message) elif message_type == 'Quote': self.handle_ticker_message(client, message) else: if self.verbose: print(f"未知消息类型: {message_type}") except Exception as e: if self.verbose: print(f"处理WebSocket消息失败: {e}, message: {message}") def handle_order_update_message(self, client: Client, message): """处理 OrderUpdate 类型消息（包含订单、持仓、余额）""" try: data = self.safe_value(message, 'data', {}) timestamp = self.safe_integer(message, 'timestampUTC') - self.diff_milliseconds # 1. 解析余额信息 balance_data = self.parse_ws_balance_from_data(data) if balance_data: balance_data['timestamp'] = timestamp balance_data['datetime'] = self.iso8601(timestamp) self.balance = balance_data client.resolve(balance_data, 'balance') else: # 即使没有余额数据，也返回空余额 client.resolve(self.safe_balance({}), 'balance') # 2. 解析订单信息（从 update.order） update_data = self.safe_value(data, 'update', {}) order_data = self.safe_value(update_data, 'order') if order_data: order_data['update_type'] = self.safe_value(update_data, 'type', None) # 这个字段可以判断是开仓还是平仓 order = self.parse_ws_order(order_data) if order: # 使用简单的列表而不是 ArrayCacheBySymbolById if not hasattr(self, 'orders_list'): self.orders_list = [] # 更新或添加订单 self.update_or_add_order(order) client.resolve(self.orders_list.copy(), 'orders') else: # 即使没有订单数据，也返回空列表 if not hasattr(self, 'orders_list'): self.orders_list = [] client.resolve(self.orders_list.copy(), 'orders') # 3. 解析持仓信息（从 openedOrders） opened_orders = self.safe_value(data, 'openedOrders', []) positions = self.parse_ws_positions_from_orders(opened_orders) # 总是返回持仓列表，即使为空 if not hasattr(self, 'positions_list'): self.positions_list = [] # 完全替换持仓列表 self.positions_list = positions client.resolve(self.positions_list.copy(), 'positions') # 4. 返回所有数据（用于 watch_all） all_data = { 'balance': balance_data if balance_data else self.safe_balance({}), 'orders': self.orders_list.copy() if hasattr(self, 'orders_list') else [], 'positions': self.positions_list.copy() if hasattr(self, 'positions_list') else [], 'timestamp': timestamp, } client.resolve(all_data, 'all_data') except Exception as e: error = ExchangeError(f"解析OrderUpdate消息失败: {e}") client.reject(error, 'balance') client.reject(error, 'orders') client.reject(error, 'positions') client.reject(error, 'all_data') def handle_opened_orders_message(self, client: Client, message): """处理 OpenedOrders 类型消息（只包含持仓）""" try: data = self.safe_value(message, 'data', []) timestamp = self.safe_integer(message, 'timestampUTC') - self.diff_milliseconds # 解析持仓信息 positions = self.parse_ws_positions_from_orders(data) # 总是返回持仓列表，即使为空 if not hasattr(self, 'positions_list'): self.positions_list = [] # 完全替换持仓列表 self.positions_list = positions client.resolve(self.positions_list.copy(), 'positions') # 返回所有数据（持仓数据） all_data = { 'balance': None, 'orders': [], 'positions': self.positions_list.copy() if hasattr(self, 'positions_list') else [], 'timestamp': timestamp, } client.resolve(all_data, 'all_data') except Exception as e: error = ExchangeError(f"解析OpenedOrders消息失败: {e}") client.reject(error, 'positions') client.reject(error, 'all_data') def handle_ohlc_message(self, client: Client, message): """处理K线数据消息""" try: data = self.safe_value(message, 'data', {}) symbol = self.safe_string(data, 'symbol') if symbol and len(symbol) >= 6: base = symbol[:3] quote = symbol[3:] symbol = base + '/' + quote # 获取时间帧 timeframe_value = self.safe_integer(data, 'timeframe') timeframe = self.parse_timeframe_from_value(timeframe_value) # 构建消息哈希 message_hash = 'ohlcv:' + symbol + ':' + timeframe # 解析K线数据 ohlcv = self.parse_ws_ohlcv_message(data) # 更新缓存 if not hasattr(self, 'ohlcv_cache'): self.ohlcv_cache = {} if symbol not in self.ohlcv_cache: self.ohlcv_cache[symbol] = {} stored = self.ohlcv_cache[symbol].get(timeframe) if stored is None: limit = self.safe_integer(self.options, 'OHLCVLimit', 1000) # 使用简单的列表代替 ArrayCacheByTimestamp stored = [] self.ohlcv_cache[symbol][timeframe] = stored # 添加新的K线数据 stored.append(ohlcv) # 限制缓存大小 if len(stored) > self.options['OHLCVLimit']: stored = stored[-self.options['OHLCVLimit']:] self.ohlcv_cache[symbol][timeframe] = stored # 返回数据 client.resolve(stored, message_hash) except Exception as e: if self.verbose: print(f"处理K线消息失败: {e}") # 拒绝相关的promise symbol = self.safe_string(message.get('data', {}), 'symbol') if symbol and len(symbol) >= 6: base = symbol[:3] quote = symbol[3:] symbol = base + '/' + quote timeframe_value = self.safe_integer(message.get('data', {}), 'timeframe') timeframe = self.parse_timeframe_from_value(timeframe_value) message_hash = 'ohlcv:' + symbol + ':' + timeframe client.reject(e, message_hash) def handle_ticker_message(self, client: Client, message): """处理行情数据消息""" try: data = self.safe_value(message, 'data', {}) symbol = self.safe_string(data, 'symbol') if symbol and len(symbol) >= 6: base = symbol[:3] quote = symbol[3:] symbol = base + '/' + quote # 构建消息哈希 message_hash = 'ticker:' + symbol # 解析行情数据 ticker = self.parse_ws_ticker_message(data) # 更新缓存 if not hasattr(self, 'ticker_cache'): self.ticker_cache = {} self.ticker_cache[symbol] = ticker # 返回数据 client.resolve(ticker, message_hash) except Exception as e: if self.verbose: print(f"处理行情消息失败: {e}") # 拒绝相关的promise symbol = self.safe_string(message.get('data', {}), 'symbol') if symbol and len(symbol) >= 6: base = symbol[:3] quote = symbol[3:] symbol = base + '/' + quote message_hash = 'ticker:' + symbol client.reject(e, message_hash) def update_or_add_order(self, order): """更新或添加订单到列表""" if not hasattr(self, 'orders_list'): self.orders_list = [] order_id = order['id'] # 查找是否已存在相同ID的订单 existing_index = -1 for i, existing_order in enumerate(self.orders_list): if existing_order['id'] == order_id: existing_index = i break if existing_index >= 0: # 更新现有订单 self.orders_list[existing_index] = order else: # 添加新订单 self.orders_list.append(order) # 限制订单列表长度 if len(self.orders_list) > self.options['ordersLimit']: self.orders_list = self.orders_list[-self.options['ordersLimit']:] def parse_ws_balance_from_data(self, data): """从数据中解析余额信息""" result = { 'timestamp': None, 'datetime': None, } currency = 'USDT' balance = self.safe_number(data, 'balance', 0) equity = self.safe_number(data, 'equity', 0) margin = self.safe_number(data, 'margin', 0) free_margin = self.safe_number(data, 'freeMargin', 0) profit = self.safe_number(data, 'profit', 0) result[currency] = { 'free': free_margin, 'used': margin, 'total': balance, 'equity': equity, 'profit': profit, } return self.safe_balance(result) def parse_ws_order(self, order_data): """解析单个订单数据""" if not order_data: return None # print("++++++",order_data) try: symbol = self.safe_string(order_data, 'symbol') if symbol and len(symbol) >= 6: base = symbol[:3] quote = symbol[3:] symbol = base + '/' + quote # 确定订单状态 state = self.safe_string(order_data, 'state') status = self.parse_order_status(state) # 确定订单是否已关闭 close_time = self.safe_string(order_data, 'closeTime') is_closed = close_time and close_time != "0001-01-01T00:00:00" timestamp = self.safe_integer(order_data, 'openTimestampUTC') - self.diff_milliseconds last_trade_timestamp = self.safe_integer(order_data, 'closeTimestampUTC') if last_trade_timestamp is None or last_trade_timestamp <= 0: last_trade_timestamp = timestamp else: last_trade_timestamp = last_trade_timestamp - self.diff_milliseconds mt5_order_type = self.safe_string(order_data, 'update_type', None) amount = self.safe_number(order_data, 'lots', 0) filled = self.safe_number(order_data, 'closeLots', 0) price = self.safe_number(order_data, 'openPrice') side = self.parse_order_side(self.safe_string(order_data, 'orderType')) if mt5_order_type == 'MarketOpen': amount = self.safe_number(order_data, 'lots', 0) filled = self.safe_number(order_data, 'lots', 0) elif mt5_order_type == 'MarketClose': amount = self.safe_number(self.safe_dict(order_data, 'dealInternalIn', {}), 'lots', 0) filled = self.safe_number(order_data, 'closeLots', 0) price = self.safe_number(order_data, 'closePrice') if side == 'buy': side = 'sell' else: side = 'buy' remaining = max(amount - filled, 0) if amount is not None and filled is not None else None return { 'id': self.safe_string(order_data, 'ticket'), 'clientOrderId': self.safe_string(order_data, 'comment'), 'datetime': self.iso8601(timestamp), 'timestamp': timestamp, 'lastTradeTimestamp': last_trade_timestamp, 'lastUpdateTimestamp': last_trade_timestamp, 'status': status, 'symbol': symbol, 'type': self.parse_order_type(self.safe_string(order_data, 'orderType')), 'timeInForce': None, 'postOnly': None, 'side': side, 'price': price, 'stopLossPrice': self.safe_number(order_data, 'stopLoss'), 'takeProfitPrice': self.safe_number(order_data, 'takeProfit'), 'reduceOnly': None, 'triggerPrice': None, 'amount': amount, 'filled': filled, 'remaining': remaining, 'cost': None, 'trades': None, 'fee': { 'cost': self.safe_number(order_data, 'commission', 0) + self.safe_number(order_data, 'fee', 0), 'currency': None, }, 'average': None, 'info': order_data, } except Exception as e: if self.verbose: print(f"解析订单数据失败: {e}") return None def parse_ws_positions_from_orders(self, orders_data): """从订单数据解析持仓信息""" positions = [] if not orders_data: return positions if not isinstance(orders_data, list): orders_data = [orders_data] for order_data in orders_data: try: # 只有状态为 Filled 的订单才被认为是持仓 state = self.safe_string(order_data, 'state') if state == 'Filled': position = self.parse_ws_position(order_data) if position: positions.append(position) except Exception as e: if self.verbose: print(f"解析持仓失败: {e}") continue return positions def parse_ws_position(self, order_data): """解析单个持仓""" symbol = self.safe_string(order_data, 'symbol') if symbol and len(symbol) >= 6: base = symbol[:3] quote = symbol[3:] symbol = base + '/' + quote timestamp = self.safe_integer(order_data, 'openTimestampUTC') - self.diff_milliseconds contracts = self.safe_number(order_data, 'lots') entry_price = self.safe_number(order_data, 'openPrice') mark_price = self.safe_number(order_data, 'closePrice') notional = contracts * entry_price if contracts and entry_price else None # 获取止损止盈价格 stop_loss_price = self.safe_number(order_data, 'stopLoss') take_profit_price = self.safe_number(order_data, 'takeProfit') # 确定持仓方向 order_type = self.safe_string(order_data, 'orderType') side = 'long' if order_type == 'Buy' else 'short' return { 'id': self.safe_string(order_data, 'ticket'), 'symbol': symbol, 'timestamp': timestamp, 'datetime': self.iso8601(timestamp), 'side': side, 'contracts': contracts, 'contractSize': self.safe_number(order_data, 'contractSize', 1.0), 'entryPrice': entry_price, 'markPrice': mark_price, 'notional': notional, 'leverage': 1, 'unrealizedPnl': self.safe_number(order_data, 'profit'), 'realizedPnl': 0, 'liquidationPrice': None, 'marginMode': 'cross', 'percentage': None, 'marginRatio': None, 'collateral': None, 'initialMargin': None, 'initialMarginPercentage': None, 'maintenanceMargin': None, 'maintenanceMarginPercentage': None, 'stopLossPrice': stop_loss_price, 'takeProfitPrice': take_profit_price, 'lastPrice': mark_price, 'hedged': None, 'info': order_data, } def parse_ws_ohlcv_message(self, data): """解析WebSocket K线数据""" timestamp = self.parse8601(self.safe_string(data, 'time')) # 确保时间戳是毫秒 if timestamp and timestamp < 1000000000000: timestamp *= 1000 return [ timestamp, # 时间戳 self.safe_number(data, 'open'), # 开盘价 self.safe_number(data, 'high'), # 最高价 self.safe_number(data, 'low'), # 最低价 self.safe_number(data, 'close'), # 收盘价 self.safe_number(data, 'volume', 0) # 成交量 ] def parse_ws_ticker_message(self, data): """解析WebSocket行情数据""" symbol = self.safe_string(data, 'symbol') if symbol and len(symbol) >= 6: base = symbol[:3] quote = symbol[3:] symbol = base + '/' + quote timestamp = self.parse8601(self.safe_string(data, 'time')) bid = self.safe_number(data, 'bid') ask = self.safe_number(data, 'ask') last = self.safe_number(data, 'last') # 如果没有 last 价格，使用中间价 if last is None and bid is not None and ask is not None: last = (bid + ask) / 2 # 计算涨跌幅（需要历史数据，这里设为None） change = None percentage = None return { 'symbol': symbol, 'timestamp': timestamp, 'datetime': self.iso8601(timestamp), 'high': None, 'low': None, 'bid': bid, 'bidVolume': None, 'ask': ask, 'askVolume': None, 'vwap': None, 'open': None, 'close': None, 'last': last, 'previousClose': None, 'change': change, 'percentage': percentage, 'average': None, 'baseVolume': self.safe_number(data, 'volume'), 'quoteVolume': None, 'info': data, } def parse_timeframe_from_value(self, timeframe_value): """将时间帧数值转换为字符串""" timeframe_map = { 1: '1m', 5: '5m', 15: '15m', 30: '30m', 60: '1h', 240: '4h', 1440: '1d', 10080: '1w', 43200: '1M' } return self.safe_string(timeframe_map, timeframe_value, '1m') async def send_ohlcv_subscription(self, request, params={}): """发送K线数据订阅请求""" try: # 方法1：尝试使用 private_get response = await self.private_get('SubscribeOhlc', self.extend(request, params)) if self.verbose: print(f"✅ K线订阅成功: {response}") # 检查订阅是否成功 if response in [True, 'OK', 'SUCCESS']: return True else: raise ExchangeError(f"订阅失败: {response}") except Exception as e: if self.verbose: print(f"private_get 失败，尝试直接HTTP请求: {e}") # 方法2：直接HTTP请求 return await self.send_direct_subscription('SubscribeOhlc', request, params) async def send_ticker_subscription(self, request, params={}): """发送行情数据订阅请求""" try: # 使用 private_get 发送订阅 response = await self.private_get('Subscribe', self.extend(request, params)) if self.verbose: print(f"✅ 行情订阅响应: {response}") # 检查订阅是否成功 if response in [True, 'OK', 'SUCCESS']: return True else: raise ExchangeError(f"行情订阅失败: {response}") except Exception as e: if self.verbose: print(f"private_get 失败，尝试直接HTTP请求: {e}") # 直接HTTP请求 return await self.send_direct_subscription('Subscribe', request, params) async def send_direct_subscription(self, endpoint, request, params={}): """直接发送订阅HTTP请求""" import aiohttp # 构建完整的URL base_url = self.urls['api']['private'] query_params = self.extend(request, params) query_string = urllib.parse.urlencode(query_params) url = f"{base_url}/{endpoint}?{query_string}" if self.verbose: print(f"🔧 直接订阅URL: {url}") try: async with aiohttp.ClientSession() as session: async with session.get(url) as response: if response.status == 200: result = await response.text() if self.verbose: print(f"✅ 直接订阅成功: {result}") return self.parse_json(result) else: error_text = await response.text() raise ExchangeError(f"订阅请求失败 {response.status}: {error_text}") except Exception as e: raise ExchangeError(f"订阅请求错误: {e}") def handle_error_message(self, client: Client, message): """处理错误消息""" error_code = self.safe_string(message, 'errorCode') error_message = self.safe_string(message, 'message', 'Unknown error') error = ExchangeError(f"MT5 WebSocket error {error_code}: {error_message}") try: # 拒绝固定消息哈希 client.reject(error, 'balance') client.reject(error, 'orders') client.reject(error, 'positions') client.reject(error, 'all_data') # 安全地拒绝所有K线消息哈希 if hasattr(client, 'futures') and client.futures: ohlcv_hashes = [hash for hash in client.futures.keys() if isinstance(hash, str) and hash.startswith('ohlcv:')] for ohlcv_hash in ohlcv_hashes: try: client.reject(error, ohlcv_hash) except Exception as e: if self.verbose: print(f"拒绝K线消息哈希失败 {ohlcv_hash}: {e}") # 拒绝所有ticker消息哈希 if hasattr(client, 'futures') and client.futures: ticker_hashes = [hash for hash in client.futures.keys() if isinstance(hash, str) and hash.startswith('ticker:')] for ticker_hash in ticker_hashes: try: client.reject(error, ticker_hash) except Exception: pass except Exception as e: if self.verbose: print(f"错误处理失败: {e}")