From 464910dc5de653135369f0b509e542cfb5803351 Mon Sep 17 00:00:00 2001 From: Administrator Date: Thu, 25 Dec 2025 13:08:11 +0800 Subject: [PATCH] =?UTF-8?q?bitmart=E4=BC=98=E5=8C=96=E5=AE=8C=E6=88=90?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- bitmart/均线自动化开单.py | 1224 ++++++++++++++++++++++++++------ telegram/8619211027341.session | Bin 45056 -> 45056 bytes telegram/bot_session.session | Bin 49152 -> 49152 bytes telegram/sign.db | Bin 40960 -> 40960 bytes 4 files changed, 1004 insertions(+), 220 deletions(-) diff --git a/bitmart/均线自动化开单.py b/bitmart/均线自动化开单.py index 0dfdcef..1e0504f 100644 --- a/bitmart/均线自动化开单.py +++ b/bitmart/均线自动化开单.py @@ -1,46 +1,280 @@ import os import time import uuid +import datetime from dataclasses import dataclass from typing import Optional import requests +from tqdm import tqdm from loguru import logger +from DrissionPage import ChromiumPage, ChromiumOptions + from bitmart.api_contract import APIContract from bitmart.lib.cloud_exceptions import APIException -from DrissionPage import ChromiumPage, ChromiumOptions +from 交易.tools import send_dingtalk_message -# ========= 1) 配置集中 ========= @dataclass -class TradeConfig: +class StrategyConfig: + # ============================= + # 1m | ETH 永续 | 控止损≤5/日 + # ============================= + + # ===== 合约 ===== contract_symbol: str = "ETHUSDT" - leverage: str = "100" - open_type: str = "cross" # 全仓 - risk_percent: float = 0.01 # 用余额的1% + open_type: str = "cross" + leverage: str = "30" + + # ===== 浏览器配置 ===== + tge_id: int = 196495 # TGE浏览器ID + tge_url: str = "http://127.0.0.1:50326" + tge_authorization: str = "Bearer asp_174003986c9b0799677c5b2c1adb76e402735d753bc91a91" + trading_url: str = "https://derivatives.bitmart.com/zh-CN/futures/ETHUSDT" + + # ===== K线与指标 ===== + step_min: int = 1 + lookback_min: int = 240 + ema_len: int = 36 + atr_len: int = 14 + + # ========================================================= + # ✅ 自动阈值：ATR/Price 分位数基准（更稳，不被短时噪声带跑） + # ========================================================= + vol_baseline_window: int = 60 + vol_baseline_quantile: float = 0.65 + vol_scale_min: float = 0.80 + vol_scale_max: float = 1.60 + + # ✅ baseline 每 60 秒刷新一次（体感更明显、也省CPU） + base_ratio_refresh_sec: int = 60 + + # ========================================================= + # ✅ 动态 floor（方案一） + # floor = clamp(min, base_k * base_ratio, max) + # 目的：跟着典型波动变，过滤小噪声；tp/sl 也随环境自适应 + # ========================================================= + # entry_dev_floor 动态 + entry_dev_floor_min: float = 0.0012 # 0.12% + entry_dev_floor_max: float = 0.0030 # 0.30%（可按你偏好调） + entry_dev_floor_base_k: float = 1.10 # entry_floor = 1.10 * base_ratio + + # tp_floor 动态 + tp_floor_min: float = 0.0006 # 0.06% + tp_floor_max: float = 0.0020 # 0.20% + tp_floor_base_k: float = 0.55 # tp_floor = 0.55 * base_ratio（止盈别太大，1m回归更实际） + + # sl_floor 动态 + sl_floor_min: float = 0.0018 # 0.18% + sl_floor_max: float = 0.0060 # 0.60% + sl_floor_base_k: float = 1.35 # sl_floor = 1.35 * base_ratio（ETH 1m 插针多，止损下限可更稳） + + # ========================================================= + # ✅ 动态阈值倍率（仍然保留你原来思路） + # ========================================================= + entry_k: float = 1.45 + tp_k: float = 0.65 + sl_k: float = 1.05 + + # ===== 时间/冷却 ===== + max_hold_sec: int = 75 + cooldown_sec_after_exit: int = 20 + + # ===== 下单/仓位 ===== + risk_percent: float = 0.004 min_size: int = 1 max_size: int = 5000 - # TGE - tge_url: str = "http://127.0.0.1:50326" - tge_id: int = 196495 - tge_token: str = os.getenv("TGE_TOKEN", "") - tge_auth_header: str = "Authorization" + # ===== 日内风控 ===== + daily_loss_limit: float = 0.02 + daily_profit_cap: float = 0.01 + + # ===== 危险模式过滤 ===== + atr_ratio_kill: float = 0.0038 + big_body_kill: float = 0.010 + + # ===== 轮询节奏 ===== + klines_refresh_sec: int = 10 + tick_refresh_sec: int = 1 + status_notify_sec: int = 60 + + # ========================================================= + # ✅ 止损后同向入场加门槛（但不禁止同向重入） + # ========================================================= + reentry_penalty_mult: float = 1.55 + reentry_penalty_max_sec: int = 180 + reset_band_k: float = 0.45 + reset_band_floor: float = 0.0006 + + # ========================================================= + # ✅ 止损后同方向 SL 放宽幅度与"止损时 vol_scale"联动 + # ========================================================= + post_sl_sl_max_sec: int = 90 + post_sl_mult_min: float = 1.02 + post_sl_mult_max: float = 1.16 + post_sl_vol_alpha: float = 0.20 -# ========= 2) API 封装（查询 + 平仓）========= -class BitmartApi: - def __init__(self, cfg: TradeConfig): - api_key = "a0fb7b98464fd9bcce67e7c519d58ec10d0c38a8" - secret_key = "4eaeba78e77aeaab1c2027f846a276d164f264a44c2c1bb1c5f3be50c8de1ca5" - memo = "合约交易" - - if not api_key or not secret_key: - raise RuntimeError("请设置环境变量 BITMART_API_KEY / BITMART_SECRET_KEY") - +class BitmartFuturesMeanReversionBot: + def __init__(self, cfg: StrategyConfig): self.cfg = cfg - self.contractAPI = APIContract(api_key, secret_key, memo, timeout=(5, 15)) + + self.api_key = "a0fb7b98464fd9bcce67e7c519d58ec10d0c38a8" + self.secret_key = "4eaeba78e77aeaab1c2027f846a276d164f264a44c2c1bb1c5f3be50c8de1ca5" + self.memo = "合约交易" + + if not self.api_key or not self.secret_key: + raise RuntimeError("请先设置环境变量 BITMART_API_KEY / BITMART_SECRET_KEY / BITMART_MEMO(可选)") + + self.contractAPI = APIContract(self.api_key, self.secret_key, self.memo, timeout=(5, 15)) + + # 持仓状态: -1 空, 0 无, 1 多 + self.pos = 0 + self.entry_price = None + self.entry_ts = None + self.last_exit_ts = 0 + + # 日内权益基准 + self.day_start_equity = None + self.trading_enabled = True + self.day_tag = datetime.date.today() + + # 缓存 + self._klines_cache = None + self._klines_cache_ts = 0 + self._last_status_notify_ts = 0 + + # ✅ base_ratio 缓存 + self._base_ratio_cached = 0.0015 # 初始化默认值 0.15% + self._base_ratio_ts = 0.0 + + # ✅ 止损后"同向入场加门槛"状态 + self.last_sl_dir = 0 # 1=多止损，-1=空止损，0=无 + self.last_sl_ts = 0.0 + + # ✅ 止损后"同方向 SL 联动放宽"状态 + self.post_sl_dir = 0 + self.post_sl_ts = 0.0 + self.post_sl_vol_scale = 1.0 # 记录止损时的 vol_scale + + # ✅ 浏览器自动化相关 + self.tge_port: Optional[int] = None + self.page: Optional[ChromiumPage] = None + self.browser_initialized = False + + self.pbar = tqdm(total=60, desc="运行中(秒)", ncols=90) + + logger.info(f"初始化完成，基准波动率默认值: {self._base_ratio_cached * 100:.4f}%") + + # ----------------- 浏览器自动化相关 ----------------- + def open_browser(self) -> bool: + """打开 TGE 对应浏览器实例""" + try: + tge_headers = { + "Authorization": self.cfg.tge_authorization, + "Content-Type": "application/json" + } + res = requests.post( + f"{self.cfg.tge_url}/api/browser/start", + json={"envId": self.cfg.tge_id}, + headers=tge_headers, + timeout=10 + ) + self.tge_port = res.json()["data"]["port"] + logger.success(f"成功打开浏览器，端口：{self.tge_port}") + return True + except Exception as e: + logger.error(f"打开浏览器失败: {e}") + self.ding(f"打开浏览器失败: {e}", error=True) + return False + + def take_over_browser(self) -> bool: + """接管浏览器""" + if not self.tge_port: + logger.error("浏览器端口未设置") + return False + + try: + co = ChromiumOptions() + co.set_local_port(self.tge_port) + self.page = ChromiumPage(addr_or_opts=co) + self.page.set.window.max() + logger.success("成功接管浏览器") + return True + except Exception as e: + logger.error(f"接管浏览器失败: {e}") + self.ding(f"接管浏览器失败: {e}", error=True) + return False + + def close_extra_tabs(self) -> bool: + """关闭多余 tab""" + if not self.page: + return False + + try: + for idx, tab in enumerate(self.page.get_tabs()): + if idx > 0: + tab.close() + return True + except Exception as e: + logger.warning(f"关闭多余标签页失败: {e}") + return False + + def initialize_browser(self) -> bool: + """初始化浏览器（打开、接管、导航到交易页面）""" + if self.browser_initialized: + return True + + # 打开浏览器 + if not self.open_browser(): + return False + + # 接管浏览器 + if not self.take_over_browser(): + return False + + # 关闭多余标签页 + self.close_extra_tabs() + + # 导航到交易页面 + try: + self.page.get(self.cfg.trading_url) + time.sleep(2) # 等待页面加载 + logger.success("已导航到交易页面") + except Exception as e: + logger.error(f"导航到交易页面失败: {e}") + self.ding(f"导航到交易页面失败: {e}", error=True) + return False + + self.browser_initialized = True + return True + + def click_safe(self, xpath: str, sleep: float = 0.5) -> bool: + """安全点击""" + if not self.page: + return False + + try: + ele = self.page.ele(xpath) + if not ele: + return False + ele.scroll.to_see(center=True) + time.sleep(sleep) + ele.click() + return True + except Exception as e: + logger.error(f"点击失败 {xpath}: {e}") + return False + + # ----------------- 通用工具 ----------------- + def ding(self, msg, error=False): + prefix = "❌bitmart：" if error else "🔔bitmart：" + if error: + for _ in range(3): + send_dingtalk_message(f"{prefix}{msg}") + else: + send_dingtalk_message(f"{prefix}{msg}") def set_leverage(self) -> bool: try: @@ -50,15 +284,294 @@ class BitmartApi: open_type=self.cfg.open_type )[0] if resp.get("code") == 1000: - logger.success(f"杠杆设置成功：{self.cfg.open_type} + {self.cfg.leverage}x") + logger.success(f"设置杠杆成功：{self.cfg.open_type} + {self.cfg.leverage}x") return True - logger.error(f"杠杆设置失败: {resp}") + logger.error(f"设置杠杆失败: {resp}") + self.ding(f"设置杠杆失败: {resp}", error=True) return False except Exception as e: - logger.exception(e) + logger.error(f"设置杠杆异常: {e}") + self.ding(f"设置杠杆异常: {e}", error=True) return False - def get_available_balance(self) -> float: + # ----------------- 行情/指标 ----------------- + def get_klines_cached(self): + now = time.time() + if self._klines_cache is not None and (now - self._klines_cache_ts) < self.cfg.klines_refresh_sec: + return self._klines_cache + + kl = self.get_klines() + if kl: + self._klines_cache = kl + self._klines_cache_ts = now + return self._klines_cache + + def get_klines(self): + try: + end_time = int(time.time()) + start_time = end_time - 60 * self.cfg.lookback_min + + resp = self.contractAPI.get_kline( + contract_symbol=self.cfg.contract_symbol, + step=self.cfg.step_min, + start_time=start_time, + end_time=end_time + )[0] + + if resp.get("code") != 1000: + logger.error(f"获取K线失败: {resp}") + return None + + data = resp.get("data", []) + formatted = [] + for k in data: + formatted.append({ + "id": int(k["timestamp"]), + "open": float(k["open_price"]), + "high": float(k["high_price"]), + "low": float(k["low_price"]), + "close": float(k["close_price"]), + }) + formatted.sort(key=lambda x: x["id"]) + return formatted + except Exception as e: + logger.error(f"获取K线异常: {e}") + self.ding(f"获取K线异常: {e}", error=True) + return None + + def get_last_price(self, fallback_close: float) -> float: + try: + if hasattr(self.contractAPI, "get_contract_details"): + r = self.contractAPI.get_contract_details(contract_symbol=self.cfg.contract_symbol)[0] + d = r.get("data") if isinstance(r, dict) else None + if isinstance(d, dict): + for key in ("last_price", "mark_price", "index_price"): + if key in d and d[key] is not None: + return float(d[key]) + + if hasattr(self.contractAPI, "get_ticker"): + r = self.contractAPI.get_ticker(contract_symbol=self.cfg.contract_symbol)[0] + d = r.get("data") if isinstance(r, dict) else None + if isinstance(d, dict): + for key in ("last_price", "price", "last", "close"): + if key in d and d[key] is not None: + return float(d[key]) + except Exception: + pass + + return float(fallback_close) + + @staticmethod + def ema(values, n: int) -> float: + k = 2 / (n + 1) + e = values[0] + for v in values[1:]: + e = v * k + e * (1 - k) + return e + + @staticmethod + def atr(klines, n: int) -> float: + if len(klines) < n + 1: + return 0.0 + trs = [] + for i in range(-n, 0): + cur = klines[i] + prev = klines[i - 1] + tr = max( + cur["high"] - cur["low"], + abs(cur["high"] - prev["close"]), + abs(cur["low"] - prev["close"]), + ) + trs.append(tr) + return sum(trs) / len(trs) + + def is_danger_market(self, klines, price: float) -> bool: + last = klines[-1] + body = abs(last["close"] - last["open"]) / last["open"] if last["open"] else 0.0 + if body >= self.cfg.big_body_kill: + return True + + a = self.atr(klines, self.cfg.atr_len) + atr_ratio = (a / price) if price > 0 else 0.0 + if atr_ratio >= self.cfg.atr_ratio_kill: + return True + + return False + + def atr_ratio_baseline(self, klines) -> float: + """简化版ATR基准计算""" + window = min(self.cfg.vol_baseline_window, len(klines) - self.cfg.atr_len - 1) + if window <= 10: # 数据太少 + logger.warning(f"数据不足计算基准: {len(klines)}根K线") + return 0.0 + + ratios = [] + + # 简化计算：每隔3根K线计算一个ATR比率（减少计算量） + step = 3 + for i in range(-window, 0, step): + if len(klines) + i < self.cfg.atr_len + 1: + continue + + # 计算当前位置的ATR + start_idx = len(klines) + i - self.cfg.atr_len + end_idx = len(klines) + i + + if start_idx < 0 or end_idx <= start_idx: + continue + + sub_klines = klines[start_idx:end_idx] + + # 确保有足够数据计算ATR + if len(sub_klines) >= self.cfg.atr_len + 1: + a = self.atr(sub_klines, self.cfg.atr_len) + price = klines[end_idx - 1]["close"] + + if a > 0 and price > 0: + ratio = a / price + if 0.0001 < ratio < 0.01: # 过滤异常值 + ratios.append(ratio) + + if len(ratios) < 5: # 样本太少 + # 尝试直接使用整个数据计算一个ATR比率 + a = self.atr(klines[-60:], self.cfg.atr_len) # 使用最近60根K线 + price = klines[-1]["close"] + if a > 0 and price > 0: + baseline = a / price + logger.debug(f"使用全量数据计算基准: {baseline * 100:.4f}%") + return baseline + else: + return 0.0 + + # 计算分位数 + ratios.sort() + idx = min(len(ratios) - 1, + max(0, int(self.cfg.vol_baseline_quantile * (len(ratios) - 1)))) + baseline = ratios[idx] + + logger.debug(f"基准计算: 样本数={len(ratios)}, 基准={baseline * 100:.4f}%, " + f"范围=[{ratios[0] * 100:.4f}%, {ratios[-1] * 100:.4f}%]") + + return baseline + + def get_base_ratio_cached(self, klines) -> float: + """获取缓存的基准波动率，定期刷新""" + now = time.time() + refresh_sec = self.cfg.base_ratio_refresh_sec + + if (self._base_ratio_cached is None or + (now - self._base_ratio_ts) >= refresh_sec): + + # 使用简单版本的基准计算 + baseline = self.atr_ratio_baseline(klines) + + if baseline > 0.0001: # 大于0.01%才认为是有效值 + self._base_ratio_cached = baseline + self._base_ratio_ts = now + logger.info(f"基准波动率更新: {baseline * 100:.4f}%") + else: + # 使用基于价格的动态默认值 + current_price = klines[-1]["close"] if klines else 3000 + # ETH价格越高，基准波动率越小（百分比） + if current_price > 4000: + default_baseline = 0.0010 # 0.10% + elif current_price > 3500: + default_baseline = 0.0012 # 0.12% + elif current_price > 3000: + default_baseline = 0.0015 # 0.15% + elif current_price > 2500: + default_baseline = 0.0018 # 0.18% + else: + default_baseline = 0.0020 # 0.20% + + self._base_ratio_cached = default_baseline + self._base_ratio_ts = now + logger.warning(f"使用价格动态默认基准: {default_baseline * 100:.4f}% " + f"(价格=${current_price:.0f})") + + return self._base_ratio_cached + + @staticmethod + def _clamp(x: float, lo: float, hi: float) -> float: + """限制数值在指定范围内""" + return max(lo, min(hi, x)) + + def dynamic_thresholds(self, atr_ratio: float, base_ratio: float): + """ + ✅ entry/tp/sl 全部动态（修复版）： + - vol_scale：atr_ratio/base_ratio 限幅 + - floor：方案一 (floor = clamp(min, k*base_ratio, max)) + - 最终阈值：max(floor, k * vol_scale * atr_ratio) + """ + # 1) 检查输入有效性 + if atr_ratio <= 0: + logger.warning(f"ATR比率异常: {atr_ratio}") + atr_ratio = 0.001 # 默认值 0.1% + + # 2) 如果base_ratio太小或无效，使用调整后的atr_ratio + if base_ratio < 0.0005: # 小于0.05%视为无效 + base_ratio = max(0.001, atr_ratio * 1.2) # 比当前ATR比率稍大 + logger.debug(f"基准太小，使用调整后的atr_ratio: {base_ratio * 100:.4f}%") + + # 3) vol_scale计算 + if base_ratio > 0: + raw_scale = atr_ratio / base_ratio + vol_scale = self._clamp(raw_scale, self.cfg.vol_scale_min, self.cfg.vol_scale_max) + logger.debug( + f"vol_scale: {raw_scale:.2f} → {vol_scale:.2f} (atr={atr_ratio * 100:.3f}%, base={base_ratio * 100:.3f}%)") + else: + vol_scale = 1.0 + logger.warning(f"基准无效，使用默认vol_scale=1.0") + + # 4) 动态floor计算 + # Entry floor + entry_floor_raw = self.cfg.entry_dev_floor_base_k * base_ratio + entry_floor = self._clamp( + entry_floor_raw, + self.cfg.entry_dev_floor_min, + self.cfg.entry_dev_floor_max, + ) + + # TP floor + tp_floor_raw = self.cfg.tp_floor_base_k * base_ratio + tp_floor = self._clamp( + tp_floor_raw, + self.cfg.tp_floor_min, + self.cfg.tp_floor_max, + ) + + # SL floor + sl_floor_raw = self.cfg.sl_floor_base_k * base_ratio + sl_floor = self._clamp( + sl_floor_raw, + self.cfg.sl_floor_min, + self.cfg.sl_floor_max, + ) + + # 5) 最终阈值计算 + entry_dev_atr_part = self.cfg.entry_k * vol_scale * atr_ratio + entry_dev = max(entry_floor, entry_dev_atr_part) + + tp_atr_part = self.cfg.tp_k * vol_scale * atr_ratio + tp = max(tp_floor, tp_atr_part) + + sl_atr_part = self.cfg.sl_k * vol_scale * atr_ratio + sl = max(sl_floor, sl_atr_part) + + # 6) 确保entry_dev不会太小 + entry_dev = max(entry_dev, self.cfg.entry_dev_floor_min) + + # 7) 输出详细信息 + logger.info( + f"动态阈值: atr={atr_ratio * 100:.4f}%, base={base_ratio * 100:.4f}%, " + f"vol_scale={vol_scale:.2f}, floor={entry_floor * 100:.4f}%, " + f"atr_part={entry_dev_atr_part * 100:.4f}%, 最终entry_dev={entry_dev * 100:.4f}%" + ) + + return entry_dev, tp, sl, vol_scale, entry_floor, tp_floor, sl_floor + + # ----------------- 账户/仓位 ----------------- + def get_assets_available(self) -> float: try: resp = self.contractAPI.get_assets_detail()[0] if resp.get("code") != 1000: @@ -67,54 +580,195 @@ class BitmartApi: if isinstance(data, dict): return float(data.get("available_balance", 0)) if isinstance(data, list): - for a in data: - if a.get("currency") == "USDT": - return float(a.get("available_balance", 0)) + for asset in data: + if asset.get("currency") == "USDT": + return float(asset.get("available_balance", 0)) return 0.0 except Exception as e: - logger.exception(e) + logger.error(f"余额查询异常: {e}") return 0.0 - def get_last_price(self) -> Optional[float]: - """尽量用 ticker/contract_details；不行再退化到 kline""" - try: - if hasattr(self.contractAPI, "get_contract_details"): - r = self.contractAPI.get_contract_details(contract_symbol=self.cfg.contract_symbol)[0] - d = r.get("data") - if isinstance(d, dict): - for k in ("last_price", "mark_price", "index_price"): - if d.get(k) is not None: - return float(d[k]) - except Exception: - pass - return None - - def get_position(self) -> dict: - """返回原始持仓信息（你策略里爱怎么用怎么用）""" + def get_position_status(self) -> bool: try: resp = self.contractAPI.get_position(contract_symbol=self.cfg.contract_symbol)[0] if resp.get("code") != 1000: - return {} - data = resp.get("data") or [] - return data[0] if data else {} - except Exception as e: - logger.exception(e) - return {} + return False - def close_all_market(self) -> bool: - """用 API 市价一键平仓（比网页稳）""" - p = self.get_position() - if not p: + positions = resp.get("data", []) + if not positions: + self.pos = 0 + return True + + p = positions[0] + self.pos = 1 if p["position_type"] == 1 else -1 return True + except Exception as e: + logger.error(f"持仓查询异常: {e}") + self.ding(f"持仓查询异常: {e}", error=True) + return False - pos_type = p.get("position_type") # 1=多 2=空(按你账户实际字段确认) - if pos_type == 1: - side = 3 # 平多（你原逻辑） - else: - side = 2 # 平空（你原逻辑） + def get_equity_proxy(self) -> float: + return self.get_assets_available() + + def refresh_daily_baseline(self): + today = datetime.date.today() + if today != self.day_tag: + self.day_tag = today + self.day_start_equity = None + self.trading_enabled = True + self.ding(f"新的一天({today})：重置日内风控基准") + + def risk_kill_switch(self): + self.refresh_daily_baseline() + equity = self.get_equity_proxy() + if equity <= 0: + return + + if self.day_start_equity is None: + self.day_start_equity = equity + logger.info(f"日内权益基准设定：{equity:.2f} USDT") + return + + pnl = (equity - self.day_start_equity) / self.day_start_equity + if pnl <= -self.cfg.daily_loss_limit: + self.trading_enabled = False + self.ding(f"触发日止损：{pnl * 100:.2f}% -> 停机", error=True) + + if pnl >= self.cfg.daily_profit_cap: + self.trading_enabled = False + self.ding(f"达到日盈利封顶：{pnl * 100:.2f}% -> 停机") + + # ----------------- 下单（使用浏览器自动化） ----------------- + def calculate_size(self, price: float) -> int: + bal = self.get_assets_available() + if bal < 10: + return 0 + + margin = bal * self.cfg.risk_percent + lev = int(self.cfg.leverage) + + # ⚠️ 沿用你的原假设：1张≈0.001ETH + size = int((margin * lev) / (price * 0.001)) + size = max(self.cfg.min_size, size) + size = min(self.cfg.max_size, size) + return size + + def place_market_order(self, side: int, size: int) -> bool: + """ + 使用浏览器自动化开单（市价单） + + Args: + side: 1=开多, 4=开空 + size: 数量（张数） + + Returns: + 是否成功 + """ + if size <= 0: + return False + + # 确保浏览器已初始化 + if not self.browser_initialized: + if not self.initialize_browser(): + logger.error("浏览器初始化失败，无法开单") + self.ding("浏览器初始化失败，无法开单", error=True) + return False try: - client_order_id = f"close_{int(time.time())}_{uuid.uuid4().hex[:6]}" + # 刷新页面确保在交易页面 + if self.page: + self.page.get(self.cfg.trading_url) + time.sleep(1) + + # 根据side判断方向 + if side == 1: + # 开多：点击市价，输入数量，点击买入/做多 + if not self.click_safe('x://button[normalize-space(text()) ="市价"]'): + logger.error("点击市价按钮失败") + return False + + # 输入数量 + try: + size_input = self.page.ele('x://*[@id="size_0"]') + if size_input: + size_input.input(str(size)) + time.sleep(0.5) + else: + logger.error("找不到数量输入框") + return False + except Exception as e: + logger.error(f"输入数量失败: {e}") + return False + + # 点击买入/做多 + if not self.click_safe('x://span[normalize-space(text()) ="买入/做多"]'): + logger.error("点击买入/做多按钮失败") + return False + + logger.success(f"浏览器自动化开多成功: size={size}") + return True + + elif side == 4: + # 开空：点击市价，输入数量，点击卖出/做空 + if not self.click_safe('x://button[normalize-space(text()) ="市价"]'): + logger.error("点击市价按钮失败") + return False + + # 输入数量 + try: + size_input = self.page.ele('x://*[@id="size_0"]') + if size_input: + size_input.input(str(size)) + time.sleep(0.5) + else: + logger.error("找不到数量输入框") + return False + except Exception as e: + logger.error(f"输入数量失败: {e}") + return False + + # 点击卖出/做空 + if not self.click_safe('x://span[normalize-space(text()) ="卖出/做空"]'): + logger.error("点击卖出/做空按钮失败") + return False + + logger.success(f"浏览器自动化开空成功: size={size}") + return True + else: + logger.error(f"不支持的side参数: {side} (只支持1=开多, 4=开空)") + return False + + except Exception as e: + logger.error(f"浏览器自动化开单异常: {e}") + self.ding(f"浏览器自动化开单异常: {e}", error=True) + return False + + def close_position_all(self): + """ + 使用API平仓（保持原有逻辑） + """ + if self.pos == 1: + ok = self.place_market_order_api(3, 999999) + if ok: + self.pos = 0 + elif self.pos == -1: + ok = self.place_market_order_api(2, 999999) + if ok: + self.pos = 0 + + def place_market_order_api(self, side: int, size: int) -> bool: + """ + 使用API下单（仅用于平仓） + + Args: + side: 2=平空, 3=平多 + size: 数量 + """ + if size <= 0: + return False + + client_order_id = f"mr_{int(time.time())}_{uuid.uuid4().hex[:8]}" + try: resp = self.contractAPI.post_submit_order( contract_symbol=self.cfg.contract_symbol, client_order_id=client_order_id, @@ -123,180 +777,310 @@ class BitmartApi: type="market", leverage=self.cfg.leverage, open_type=self.cfg.open_type, - size=999999 + size=size )[0] - ok = (resp.get("code") == 1000) - if not ok: - logger.error(f"平仓失败: {resp}") - return ok + + logger.info(f"API平仓响应: {resp}") + + if resp.get("code") == 1000: + return True + + self.ding(f"API平仓失败: {resp}", error=True) + return False + except APIException as e: - logger.error(f"平仓API异常: {e}") + logger.error(f"API平仓异常: {e}") + self.ding(f"API平仓异常: {e}", error=True) return False + except Exception as e: - logger.exception(e) + logger.error(f"API平仓未知异常: {e}") + self.ding(f"API平仓未知异常: {e}", error=True) return False - def calc_size(self, price: float) -> int: - bal = self.get_available_balance() - if bal <= 0 or price <= 0: - return 0 - margin = bal * self.cfg.risk_percent - lev = int(self.cfg.leverage) - - # ⚠️ 你原来假设：1张≈0.001ETH（按你实际合约面值调整） - size = int((margin * lev) / (price * 0.001)) - size = max(self.cfg.min_size, size) - size = min(self.cfg.max_size, size) - return size - - -# ========= 3) 网页下单封装（只负责“开仓”）========= -class BitmartWebTrader: - class X: - MARKET_BTN = 'x://button[normalize-space(text()) ="市价"]' - LIMIT_BTN = 'x://button[normalize-space(text()) ="限价"]' - SIZE_INPUT = 'x://*[@id="size_0"]' - PRICE_INPUT= 'x://*[@id="price_0"]' - BUY_LONG = 'x://span[normalize-space(text()) ="买入/做多"]' - SELL_SHORT = 'x://span[normalize-space(text()) ="卖出/做空"]' - - def __init__(self, cfg: TradeConfig): - self.cfg = cfg - self.page: Optional[ChromiumPage] = None - self._tge_port: Optional[int] = None - - def _post_with_retry(self, url, json_data, headers, retry=3, sleep=0.6): - last = None - for i in range(retry): - try: - r = requests.post(url, json=json_data, headers=headers, timeout=(5, 15)) - r.raise_for_status() - return r.json() - except Exception as e: - last = e - time.sleep(sleep) - raise last - - def open_and_takeover(self) -> None: - headers = { - self.cfg.tge_auth_header: f"Bearer {self.cfg.tge_token}", - "Content-Type": "application/json", - } - - j = self._post_with_retry( - f"{self.cfg.tge_url}/api/browser/start", - {"envId": self.cfg.tge_id}, - headers=headers - ) - self._tge_port = j["data"]["port"] - - co = ChromiumOptions() - co.set_local_port(self._tge_port) - self.page = ChromiumPage(addr_or_opts=co) - self.page.set.window.max() - - def _ele(self, xpath: str, timeout=8): - """统一等待元素出现（按 DrissionPage 版本可微调）""" - t0 = time.time() - while time.time() - t0 < timeout: - ele = self.page.ele(xpath) - if ele: - return ele - time.sleep(0.2) - return None - - def _click(self, xpath: str, timeout=8, sleep=0.2) -> bool: - ele = self._ele(xpath, timeout=timeout) - if not ele: - logger.error(f"找不到元素: {xpath}") - return False - try: - ele.scroll.to_see(center=True) - time.sleep(sleep) - ele.click() - return True - except Exception as e: - logger.error(f"点击失败 {xpath}: {e}") + # ----------------- 止损后机制 ----------------- + def _reentry_penalty_active(self, dev: float, entry_dev: float) -> bool: + """检查是否需要应用重新入场惩罚""" + if self.last_sl_dir == 0: return False - def _input(self, xpath: str, value, clear=True, timeout=8) -> bool: - ele = self._ele(xpath, timeout=timeout) - if not ele: - logger.error(f"找不到输入框: {xpath}") - return False - try: - if clear: - ele.input(vals="", clear=True) - time.sleep(0.1) - ele.input(value) - return True - except Exception as e: - logger.error(f"输入失败 {xpath}: {e}") + if (time.time() - self.last_sl_ts) > self.cfg.reentry_penalty_max_sec: + self.last_sl_dir = 0 return False - def open_market_long(self, size: int) -> bool: - return ( - self._click(self.X.MARKET_BTN) and - self._input(self.X.SIZE_INPUT, size, clear=True) and - self._click(self.X.BUY_LONG) - ) - - def open_market_short(self, size: int) -> bool: - return ( - self._click(self.X.MARKET_BTN) and - self._input(self.X.SIZE_INPUT, size, clear=True) and - self._click(self.X.SELL_SHORT) - ) - - -# ========= 4) 路由：开仓网页，平仓/查询API ========= -class OrderRouter: - def __init__(self, api: BitmartApi, web: BitmartWebTrader): - self.api = api - self.web = web - - def bootstrap(self): - if not self.api.set_leverage(): - raise RuntimeError("杠杆设置失败") - self.web.open_and_takeover() - - def open_long(self) -> bool: - price = self.api.get_last_price() - if not price: - logger.error("拿不到价格，取消开仓") + reset_band = max(self.cfg.reset_band_floor, self.cfg.reset_band_k * entry_dev) + if abs(dev) <= reset_band: + self.last_sl_dir = 0 return False - size = self.api.calc_size(price) + + return True + + def _post_sl_dynamic_mult(self) -> float: + """计算止损后SL放宽倍数""" + if self.post_sl_dir == 0: + return 1.0 + + if (time.time() - self.post_sl_ts) > self.cfg.post_sl_sl_max_sec: + self.post_sl_dir = 0 + self.post_sl_vol_scale = 1.0 + return 1.0 + + raw = 1.0 + self.cfg.post_sl_vol_alpha * (self.post_sl_vol_scale - 1.0) + raw = max(1.0, raw) # 不缩小止损，只放宽 + return max(self.cfg.post_sl_mult_min, min(self.cfg.post_sl_mult_max, raw)) + + # ----------------- 交易逻辑 ----------------- + def in_cooldown(self) -> bool: + """检查是否在冷却期内""" + return (time.time() - self.last_exit_ts) < self.cfg.cooldown_sec_after_exit + + def maybe_enter(self, price: float, ema_value: float, entry_dev: float): + """检查并执行入场""" + if self.pos != 0: + return + if self.in_cooldown(): + return + + dev = (price - ema_value) / ema_value if ema_value else 0.0 + size = self.calculate_size(price) if size <= 0: - logger.error("size=0，取消开仓") - return False - return self.web.open_market_long(size) + return - def open_short(self) -> bool: - price = self.api.get_last_price() - if not price: - logger.error("拿不到价格，取消开仓") - return False - size = self.api.calc_size(price) - if size <= 0: - logger.error("size=0，取消开仓") - return False - return self.web.open_market_short(size) + penalty_active = self._reentry_penalty_active(dev, entry_dev) - def close_all(self) -> bool: - return self.api.close_all_market() + long_th = -entry_dev + short_th = entry_dev + + if penalty_active: + if self.last_sl_dir == 1: + long_th = -entry_dev * self.cfg.reentry_penalty_mult + logger.info( + f"多头止损后惩罚生效: 入场阈值从 {long_th * 100:.3f}% 调整为 {(-entry_dev * self.cfg.reentry_penalty_mult) * 100:.3f}%") + elif self.last_sl_dir == -1: + short_th = entry_dev * self.cfg.reentry_penalty_mult + logger.info( + f"空头止损后惩罚生效: 入场阈值从 {short_th * 100:.3f}% 调整为 {(entry_dev * self.cfg.reentry_penalty_mult) * 100:.3f}%") + + logger.info( + f"入场检查: price={price:.2f}, ema={ema_value:.2f}, dev={dev * 100:.3f}% " + f"(entry_dev={entry_dev * 100:.3f}%, long_th={long_th * 100:.3f}%, short_th={short_th * 100:.3f}%) " + f"size={size}, penalty={penalty_active}, last_sl_dir={self.last_sl_dir}" + ) + + if dev <= long_th: + if self.place_market_order(1, size): + self.pos = 1 + self.entry_price = price + self.entry_ts = time.time() + self.ding(f"✅开多：dev={dev * 100:.3f}% size={size} entry={price:.2f}") + + elif dev >= short_th: + if self.place_market_order(4, size): + self.pos = -1 + self.entry_price = price + self.entry_ts = time.time() + self.ding(f"✅开空：dev={dev * 100:.3f}% size={size} entry={price:.2f}") + + def maybe_exit(self, price: float, tp: float, sl: float, vol_scale: float): + """检查并执行出场""" + if self.pos == 0 or self.entry_price is None or self.entry_ts is None: + return + + hold = time.time() - self.entry_ts + + if self.pos == 1: + pnl = (price - self.entry_price) / self.entry_price + else: + pnl = (self.entry_price - price) / self.entry_price + + sl_mult = 1.0 + if self.post_sl_dir == self.pos and self.post_sl_dir != 0: + sl_mult = self._post_sl_dynamic_mult() + effective_sl = sl * sl_mult + + if pnl >= tp: + self.close_position_all() + self.ding(f"🎯止盈：pnl={pnl * 100:.3f}% price={price:.2f} tp={tp * 100:.3f}%") + self.entry_price, self.entry_ts = None, None + self.last_exit_ts = time.time() + + elif pnl <= -effective_sl: + sl_dir = self.pos + + self.close_position_all() + self.ding( + f"🛑止损：pnl={pnl * 100:.3f}% price={price:.2f} " + f"sl={sl * 100:.3f}% effective_sl={effective_sl * 100:.3f}%(×{sl_mult:.2f})", + error=True + ) + + self.last_sl_dir = sl_dir + self.last_sl_ts = time.time() + + self.post_sl_dir = sl_dir + self.post_sl_ts = time.time() + self.post_sl_vol_scale = float(vol_scale) + + self.entry_price, self.entry_ts = None, None + self.last_exit_ts = time.time() + + elif hold >= self.cfg.max_hold_sec: + self.close_position_all() + self.ding(f"⏱超时：hold={int(hold)}s pnl={pnl * 100:.3f}% price={price:.2f}") + self.entry_price, self.entry_ts = None, None + self.last_exit_ts = time.time() + + def notify_status_throttled(self, price: float, ema_value: float, dev: float, bal: float, + atr_ratio: float, base_ratio: float, vol_scale: float, + entry_dev: float, tp: float, sl: float, + entry_floor: float, tp_floor: float, sl_floor: float): + """限频状态通知""" + now = time.time() + if (now - self._last_status_notify_ts) < self.cfg.status_notify_sec: + return + self._last_status_notify_ts = now + + direction_str = "多" if self.pos == 1 else ("空" if self.pos == -1 else "无") + penalty_active = self._reentry_penalty_active(dev, entry_dev) + + sl_mult = 1.0 + if self.pos != 0 and self.post_sl_dir == self.pos: + sl_mult = self._post_sl_dynamic_mult() + + base_age = int(now - self._base_ratio_ts) if self._base_ratio_ts else -1 + + msg = ( + f"【BitMart {self.cfg.contract_symbol}｜1m均值回归(动态阈值)】\n" + f"📊 状态：{direction_str}\n" + f"💰 现价：{price:.2f} | EMA{self.cfg.ema_len}：{ema_value:.2f}\n" + f"📈 偏离：{dev * 100:.3f}% (入场阈值：±{entry_dev * 100:.3f}%)\n" + f"🌊 波动率：ATR比={atr_ratio * 100:.3f}% | 基准={base_ratio * 100:.3f}% | 缩放={vol_scale:.2f}\n" + f"🎯 动态Floor：入场={entry_floor * 100:.3f}% | 止盈={tp_floor * 100:.3f}% | 止损={sl_floor * 100:.3f}%\n" + f"💰 止盈/止损：{tp * 100:.3f}% / {sl * 100:.3f}% (盈亏比：{tp / sl:.2f})\n" + f"🔄 基准刷新：{self.cfg.base_ratio_refresh_sec}s (已过={base_age}s)\n" + f"⚠️ 止损同向加门槛：{'开启' if penalty_active else '关闭'} (方向={self.last_sl_dir})\n" + f"💳 可用余额：{bal:.2f} USDT | 杠杆：{self.cfg.leverage}x\n" + f"⏱️ 持仓限制：{self.cfg.max_hold_sec}s | 冷却：{self.cfg.cooldown_sec_after_exit}s" + ) + self.ding(msg) + + def action(self): + """主循环""" + if not self.set_leverage(): + self.ding("杠杆设置失败，停止运行", error=True) + return + + # 初始化浏览器（延迟初始化，在需要开单时再初始化） + # 这里可以选择提前初始化，或者在place_market_order中初始化 + # 为了更好的用户体验，可以选择在这里提前初始化 + logger.info("准备初始化浏览器...") + if not self.initialize_browser(): + logger.warning("浏览器初始化失败，将在首次开单时重试") + + while True: + now_dt = datetime.datetime.now() + self.pbar.n = now_dt.second + self.pbar.refresh() + + # 1. 获取K线数据 + klines = self.get_klines_cached() + if not klines or len(klines) < (self.cfg.ema_len + 5): + logger.warning("K线数据不足，等待...") + time.sleep(1) + continue + + # 2. 计算技术指标 + last_k = klines[-1] + closes = [k["close"] for k in klines[-(self.cfg.ema_len + 1):]] + ema_value = self.ema(closes, self.cfg.ema_len) + + price = self.get_last_price(fallback_close=float(last_k["close"])) + dev = (price - ema_value) / ema_value if ema_value else 0.0 + + # 3. 计算波动率相关指标 + a = self.atr(klines, self.cfg.atr_len) + atr_ratio = (a / price) if price > 0 else 0.0 + + base_ratio = self.get_base_ratio_cached(klines) + + # 4. 计算动态阈值 + entry_dev, tp, sl, vol_scale, entry_floor, tp_floor, sl_floor = self.dynamic_thresholds( + atr_ratio, base_ratio + ) + + # 记录调试信息 + logger.debug( + f"循环数据: price={price:.2f}, ema={ema_value:.2f}, dev={dev * 100:.3f}%, " + f"atr_ratio={atr_ratio * 100:.3f}%, base_ratio={base_ratio * 100:.3f}%, " + f"entry_dev={entry_dev * 100:.3f}%" + ) + + # 5. 风控检查 + self.risk_kill_switch() + + # 6. 获取持仓状态 + if not self.get_position_status(): + time.sleep(1) + continue + + # 7. 检查交易是否启用 + if not self.trading_enabled: + if self.pos != 0: + self.close_position_all() + logger.warning("交易被禁用（风控触发），等待...") + time.sleep(5) + continue + + # 8. 检查危险市场 + if self.is_danger_market(klines, price): + logger.warning("危险模式：高波动/大实体K，暂停开仓") + self.maybe_exit(price, tp, sl, vol_scale) + time.sleep(self.cfg.tick_refresh_sec) + continue + + # 9. 执行交易逻辑 + self.maybe_exit(price, tp, sl, vol_scale) + self.maybe_enter(price, ema_value, entry_dev) + + # 10. 状态通知 + bal = self.get_assets_available() + self.notify_status_throttled( + price, ema_value, dev, bal, + atr_ratio, base_ratio, vol_scale, + entry_dev, tp, sl, + entry_floor, tp_floor, sl_floor + ) + + time.sleep(self.cfg.tick_refresh_sec) if __name__ == "__main__": - cfg = TradeConfig(tge_id=196495) - api = BitmartApi(cfg) - web = BitmartWebTrader(cfg) - router = OrderRouter(api, web) + """ + Windows PowerShell: + setx BITMART_API_KEY "你的key" + setx BITMART_SECRET_KEY "你的secret" + setx BITMART_MEMO "合约交易" + 重新打开终端再运行。 - router.bootstrap() + Linux/macOS: + export BITMART_API_KEY="你的key" + export BITMART_SECRET_KEY="你的secret" + export BITMART_MEMO "合约交易" + """ + cfg = StrategyConfig() + bot = BitmartFuturesMeanReversionBot(cfg) + + # 设置日志级别为INFO以便查看详细计算过程 + logger.remove() + logger.add(lambda msg: tqdm.write(msg, end=""), level="INFO") + + try: + bot.action() + except KeyboardInterrupt: + logger.info("程序被用户中断") + bot.ding("🤖 策略已手动停止") + except Exception as e: + logger.error(f"程序异常退出: {e}") + bot.ding(f"❌ 策略异常退出: {e}", error=True) + raise - # 示例：开多 -> 5秒后平 - ok = router.open_long() - logger.info(f"开多结果: {ok}") - time.sleep(5) - ok2 = router.close_all() - logger.info(f"平仓结果: {ok2}") diff --git a/telegram/8619211027341.session b/telegram/8619211027341.session index bf65e6b6041581005d7ca607b5da92f5c14408e6..7bbf26c6c7b6ddd0d17cf0e27c1111dea24a826f 100644 GIT binary patch delta 73 zcmZp8z|`=7X@V4!&i;uqPC#;F!jfDr`Ao-K!G^2Xi>puO%Tr?YIksBp^Jde$qb$rm a$JTECTQrdo$XK^|Vu_+PNM!QX_1*w3mmZ4% delta 73 zcmZp8z|`=7X@V4!me@oYCm^{oVM#8RoS5USptsXjo7|qvm#4()y)8`e_-50*qb$tc a+afprEt<#(WJGPASfXeR5}CYpy*B{qiyV>w diff --git a/telegram/bot_session.session b/telegram/bot_session.session index 7989bdabc7150da66d134e3854cd2d66e6fae31d..e0e33d58be9940ecd7113b86f08afb6f85a9ccf1 100644 GIT binary patch delta 322 zcmZo@U~Xt&o*>0ka&n@K6Oi1Ppqwvt*YQ@c;kxV#?1Btz42&!+O!C?j@78Ae99uJa zZoUtfd?rkO^5^__OrOt8eq0a-qMQpgm_DDIoLgAS^my^)H-+jTO0-Cc>9gWw%c4T2 zE9#rq6p1o29eKO?aIq&lkUu%WMrpG_^?YV#pJO{G8`v67X0G1>WUrgNuil>7=g7rP z4IGS2w@o&4HC|@~>3`fblL@GQa$Rd4v(L(k&F@?1Gcx{) zz;@)V=B&N@CqHQM+T1*gm4oTX`^jC4bePU$Pu{U8fa$60WUj?QAUDJ0kP%u%(2}o{CP|lY+=6EaUL!#i?5J3hu21XVZCVB0NcT+RH50*}z zoA1LVCkB(B{5k&})8ze=9~Z=dDCa^A5S3e43!>f>s)H!eA|()ISyTw5Hm@lXWdzZO zi#^#v!U;A?n+>YxGc$W1Y?*9eYdD#?eh0JnwpWw))!Q?BAF$ojzyVgz)p#9DKW>`I z1kzX6n#b(D;^yY}t@9a~y#uanp4e_F1d=#2(-cH8&oW?}ykB$H-u;sww0Lc9p2f-m z67E{01EO{;3II`Di-SN^++q_DHD$3Ph}ynb0Z47Wxwx5?*?Z^0&G9Sc_(03% S$sNnV?$es7vHA55QFZ``u!^Su diff --git a/telegram/sign.db b/telegram/sign.db index 1eecd632a96ede191affcc22705045460f1b996c..c260559da9d45ae8a13fc39316ddb43301e7626f 100644 GIT binary patch delta 184 zcmZoTz|?SnX@WFk!$cWp#)gdvt>TOto1clxaA=)o5a26h;(y71iGMf$68;JNRs1P@ zkNExg75TaO&H1+Q&E;$7D+I#W&4vb2e3RYuT3A{5elUn_KCfrQ$jNsRsK1hdf9hl& z134D{t9-jR3p$wdO-{DUW8oJDs=8{Y<;YmDsewg+S(9!3WcCSxOl<2nHioh>*%wT9 hn4uwV5@Kj%WnchAdIpAOhQ`La2BtvH<`2^ZI00;yG#&r| delta 150 zcmV;H0BQe#zyg540+1U4eUThP0e!Jxg%<%Hv*s5Z2rBph5e{(z59trm54#Vf50DRf z4`dGF4^9su4+{@B4$BU-4xJ8%4si}$voSCl4wFVMgarc>8w3Tj&n_|n3l9?j5e|6( z50wtllL{~%0uH;g5kNN%lVd(^1Qi4YA+yy!DnS8nvVa5-11JXYlLwGdv4NNdv+$M> E3F~w#z5oCK