openfund-taker 2.2.6__py3-none-any.whl → 2.2.8__py3-none-any.whl

taker/TrailingSLTaker.py

@@ -6,50 +6,26 @@ import traceback
 import pandas as pd
 # import talib as ta
 from decimal import Decimal
+
 '''
 自动设置移动止损单
 '''
 class TrailingSLTaker:
-    def __init__(self,g_config, platform_config, feishu_webhook=None, monitor_interval=4,logger=None):
-        self.trading_pairs_config = g_config.get('tradingPairs', {})
-        
-        
-        self.stop_loss_pct = float(platform_config.get("all_stop_loss_pct",2))  # 全局止损百分比
-        # 回撤比例
-        self.low_trail_stop_loss_pct = platform_config["all_low_trail_stop_loss_pct"] # 第一档
-        self.trail_stop_loss_pct = platform_config["all_trail_stop_loss_pct"]# 第二档
-        self.higher_trail_stop_loss_pct = platform_config["all_higher_trail_stop_loss_pct"]# 第三档
-        # 止损阈值
-        self.low_trail_profit_threshold = platform_config["all_low_trail_profit_threshold"]# 第一档
-        self.first_trail_profit_threshold = platform_config["all_first_trail_profit_threshold"]# 第二档
-        self.second_trail_profit_threshold = platform_config["all_second_trail_profit_threshold"]# 第三档
-        
-        # 追踪止盈回撤
-        self.open_trail_tp = platform_config.get("open_trail_tp",False)# 是否开启追踪止盈
-        self.low_trail_tp_pct = platform_config["all_low_trail_tp_pct"]# 第一档
-        self.trail_tp_pct = platform_config["all_trail_tp_pct"]# 第二档
-        self.higher_trail_tp_pct = platform_config["all_higher_trail_tp_pct"]# 第三档
-        
+    def __init__(self, g_config, platform_config, common_config=None, feishu_webhook=None, monitor_interval=4,logger=None):
+        self.g_config = g_config
+
+        if not common_config:
+            self.common_config = self.g_config.get('common', {})
+        else:
+            self.common_config = common_config
+
         self.feishu_webhook = feishu_webhook
         self.monitor_interval = monitor_interval  # 监控循环时间是分仓监控的3倍
-        
-        self.highest_total_profit = {}  # 记录最高总盈利
-        
-        # self.current_tier = {} # 记录当前的仓位模式
-        
-        self.positions_entry_price = {} # 记录每个symbol的开仓价格
-                
-        self.global_symbol_stop_loss_flag = {} # 记录每个symbol是否设置全局止损
-        self.global_symbol_stop_loss_price = {} # 记录每个symbol的止损价格
-        
-        # 保留在止盈挂单中最高最低两个价格，计算止盈价格。
-        self.max_market_price = {}
-        self.min_market_price = {}
-        
-        self.cross_directions = {} # 持仓期间，存储每个交易对的交叉方向 
+        self.logger = logger
+
         proxies = {
-            "http": g_config.get('proxy', "http://localhost:7890"),
-            "https": g_config.get('proxy', "http://localhost:7890")
+            "http": self.common_config.get('proxy', "http://localhost:7890"),
+            "https": self.common_config.get('proxy', "http://localhost:7890")
         }
         
         # 配置交易所
@@ -62,11 +38,66 @@ class TrailingSLTaker:
             'options': {'defaultType': 'future'},
             'proxies': proxies
         })
-        self.logger = logger
+
+        self.strategy_config = self.g_config.get('strategy', {})     
+        self.trading_pairs_config = self.g_config.get('tradingPairs', {})       
+        
+        # base
+    
+        self.stop_loss_pct = float(self.strategy_config.get("all_stop_loss_pct",2))  # 全局止损百分比
+        self.all_TP_SL_ratio = float(self.strategy_config.get("all_TP_SL_ratio",2))  
+        self.leverage = int(self.strategy_config.get("leverage",1)) 
+
+        # trailing_strategy
+        self.trailing_strategy_config = self.strategy_config.get('trailing_strategy', {})
+
+
+        # 设置利润触发规则      
+        self.open_trail_profit = self.trailing_strategy_config.get("open_trail_profit",False)# 是否开启追踪利润
+        self.low_trail_profit_threshold = self.trailing_strategy_config["all_low_trail_profit_threshold"]# 第一档
+        self.first_trail_profit_threshold = self.trailing_strategy_config["all_first_trail_profit_threshold"]# 第二档
+        self.second_trail_profit_threshold = self.trailing_strategy_config["all_second_trail_profit_threshold"]# 第三档
+        # 设置SL 推损规则
+        self.low_trail_stop_loss_pct = self.trailing_strategy_config["all_low_trail_stop_loss_pct"] # 第一档
+        self.trail_stop_loss_pct = self.trailing_strategy_config["all_trail_stop_loss_pct"]# 第二档
+        self.higher_trail_stop_loss_pct = self.trailing_strategy_config["all_higher_trail_stop_loss_pct"]# 第三档        
+        # 设置TP 止盈规则
+        self.open_trail_tp = self.trailing_strategy_config.get("open_trail_tp",False)# 是否开启追踪止盈
+        self.low_trail_tp_pct = self.trailing_strategy_config["all_low_trail_tp_pct"]# 第一档
+        self.trail_tp_pct = self.trailing_strategy_config["all_trail_tp_pct"]# 第二档
+        self.higher_trail_tp_pct = self.trailing_strategy_config["all_higher_trail_tp_pct"]# 第三档
+                
+        self.highest_total_profit = {}  # 记录最高总盈利        
+        self.positions_entry_price = {} # 记录每个symbol的开仓价格                
+        self.global_symbol_stop_loss_flag = {} # 记录每个symbol是否设置全局止损
+        self.global_symbol_stop_loss_price = {} # 记录每个symbol的止损价格
+        
+        # 保留在止盈挂单中最高最低两个价格，计算止盈价格。
+        self.max_market_price = {}
+        self.min_market_price = {}        
+        self.cross_directions = {} # 持仓期间，存储每个交易对的交叉方向 
+
         self.position_mode = self.get_position_mode()  # 获取持仓模式
     
     def get_pair_config(self,symbol):
-        return self.trading_pairs_config.get(symbol,{})
+        # 获取交易对特定配置,如果没有则使用全局策略配置
+        pair_config = self.trading_pairs_config.get(symbol, {})
+        
+        # 使用字典推导式合并配置,trading_pairs_config优先级高于strategy_config
+        pair_config = {
+            **self.strategy_config,  # 基础配置
+            **pair_config  # 交易对特定配置会覆盖基础配置
+        }
+        return pair_config
+
+    def format_price(self, symbol, price:Decimal) -> str:
+        precision = self.get_precision_length(symbol)
+        return f"{price:.{precision}f}"
+
+    @staticmethod
+    def toDecimal(value):
+        return Decimal(str(value))
+
     # 获取市场信息
     def getMarket(self,symbol):
         self.exchange.load_markets()
@@ -78,18 +109,19 @@ class TrailingSLTaker:
             market = self.getMarket(symbol)
             if market and 'precision' in market and 'price' in market['precision']:
                 
-                return Decimal(str(market['precision']['price']))
+                return self.toDecimal(market['precision']['price'])
             else:
-                self.logger.warn(f"{symbol}: 无法从市场数据中获取价格精度")
-                return Decimal(0.00001)  # 返回默认精度
+                # self.logger.error(f"{symbol}: 无法从市场数据中获取价格精度")
+                # return self.toDecimal("0.00001")  # 返回默认精度
+                raise ValueError(f"{symbol}: 无法从市场数据中获取价格精度")
         except Exception as e:
-            self.logger.warn(f"{symbol}: 获取市场价格精度时发生错误: {str(e)}")
-            return Decimal(0.00001)   # 发生异常时返回默认精度
-        # return float(self.getMarket(symbol)['precision']['price'])
+            self.logger.error(f"{symbol}: 获取市场价格精度时发生错误: {str(e)}")
+            self.send_feishu_notification(f"{symbol}: 获取市场价格精度时发生错误: {str(e)}")
+
     # 获取价格精度
     def get_precision_length(self,symbol) -> int:
         tick_size = self.get_tick_size(symbol)
-        return len(f"{tick_size:.10f}".rstrip('0').split('.')[1]) if '.' in f"{tick_size:.10f}" else 0
+        return len(f"{tick_size:.15f}".rstrip('0').split('.')[1]) if '.' in f"{tick_size:.15f}" else 0
     # 获取当前持仓模式
     def get_position_mode(self):
         try:
@@ -200,10 +232,10 @@ class TrailingSLTaker:
         return all(current_low <= prev_lows) and all(current_low <= next_lows)
 
 
-    def get_last_solated_point(self,symbol,position,kLines ,prd=20):
+    def get_last_solated_point(self,symbol,position, kLines ,prd=20):
         # 将K线数据转换为DataFrame格式    
         df = self.format_klines(kLines)
-    
+
         # 根据position方向寻找孤立点
         side = position['side']
         window = prd  # 设置窗口大小，用于判断局部最值
@@ -222,7 +254,7 @@ class TrailingSLTaker:
                 if self.is_pivot_low(df, i, window):
                     isolated_points.append(df.iloc[i])
                     break
-        
+
         return isolated_points
 
 
@@ -344,7 +376,7 @@ class TrailingSLTaker:
         side = position['side']
         try:
 
-            klines_period = str(pair_config.get('klines_period', '1m'))
+            klines_period = str(pair_config.get('CHF', '1m'))
             klines = self.get_historical_klines_except_last(symbol=symbol,bar=klines_period)
 
             self.logger.debug(f"开始监控 {symbol} : klines {klines_period} - {len(klines)}")
@@ -401,27 +433,26 @@ class TrailingSLTaker:
    # 计算平均利润
     def calculate_average_profit(self,symbol,position):
   
-        total_profit_pct = 0.0
+        total_profit_pct = Decimal('0')
         num_positions = 0
 
-        entry_price = float(position['entryPrice'])
-        current_price = float(position['markPrice'])
+        entry_price = self.toDecimal(position['entryPrice'])
+        current_price = self.toDecimal(position['markPrice'])
         side = position['side']
 
         # 计算单个仓位的浮动盈利百分比
-        if side == 'long':
-            profit_pct = (current_price - entry_price) / entry_price * 100
-        elif side == 'short':
-            profit_pct = (entry_price - current_price) / entry_price * 100
-        else:
+        if side not in ['long', 'short']:
             return
+            
+        # 使用三元运算符简化计算逻辑
+        profit_pct = ((current_price - entry_price) if side == 'long' else (entry_price - current_price)) / entry_price * 100
 
         # 累加总盈利百分比
         total_profit_pct += profit_pct
         num_positions += 1
-
         # 记录单个仓位的盈利情况
-        self.logger.info(f"仓位 {symbol}，方向: {side}，开仓价格: {entry_price}，当前价格: {current_price}，"
+        precision = self.get_precision_length(symbol)
+        self.logger.info(f"仓位 {symbol}，方向: {side}，开仓价格: {entry_price:.{precision}}，当前价格: {current_price:.{precision}}，"
                             f"浮动盈亏: {profit_pct:.2f}%")
 
         # 计算平均浮动盈利百分比
@@ -454,15 +485,14 @@ class TrailingSLTaker:
             self.min_market_price[symbol] = float('inf')  # 初始化为浮点数最大值
             self.cross_directions[symbol] = None
        
-    def round_price_to_tick(self,symbol, price) -> Decimal:
+    def round_price_to_tick(self, symbol, price:Decimal) -> Decimal:
         tick_size = self.get_tick_size(symbol)
-        # 计算 tick_size 的整数倍
-        # tick_decimals = len(f"{tick_size:.10f}".rstrip('0').split('.')[1]) if '.' in f"{tick_size:.10f}" else 0
-
+        # 计算 tick_size 的小数位数
+        tick_decimals = self.get_precision_length(symbol) 
         # 调整价格为 tick_size 的整数倍
-        adjusted_price = round(Decimal(price) / tick_size) * tick_size
-        return adjusted_price
-        
+        adjusted_price = round(price / tick_size) * tick_size
+        return self.toDecimal(f"{adjusted_price:.{tick_decimals}f}")
+        # return self.toDecimal(self.exchange.price_to_precision(symbol, price))
     
     def cancel_all_algo_orders(self, symbol, attachType=None) -> bool:
         """_summary_
@@ -508,7 +538,7 @@ class TrailingSLTaker:
         except Exception as e:
             self.logger.error(f"{symbol} Error cancelling order {algo_ids}: {e}")
       
-    def set_stop_loss_take_profit(self, symbol, position, stop_loss_price=None,take_profit_price=None) -> bool:
+    def set_stop_loss_take_profit(self, symbol, position, stop_loss_price:Decimal=None,take_profit_price:Decimal=None) -> bool:
         if not stop_loss_price :
             self.logger.warning(f"{symbol}: No stop loss price or take profit price provided for {symbol}")
             return False   
@@ -525,10 +555,10 @@ class TrailingSLTaker:
     
 
           
-    def set_take_profit(self, symbol, position, take_profit_price=None) -> bool:
+    def set_take_profit(self, symbol, position, take_profit_price:Decimal=None) -> bool:
 
         # 计算下单数量
-        amount = abs(float(position['contracts']))
+        amount = abs(self.toDecimal(position['contracts']))
     
         if amount <= 0:
             self.logger.warning(f"{symbol}: amount is 0 for {symbol}")
@@ -536,13 +566,13 @@ class TrailingSLTaker:
 
         
        # 止损单逻辑 
-        adjusted_price = self.round_price_to_tick(symbol, take_profit_price)
+        adjusted_price = self.format_price(symbol, take_profit_price)
          
         tp_params = {
    
             
-            'tpTriggerPx':str(adjusted_price),
-            'tpOrdPx' : str(adjusted_price),
+            'tpTriggerPx':adjusted_price,
+            'tpOrdPx' : adjusted_price,
             'tpOrdKind': 'condition',
             'tpTriggerPxType':'last',
             
@@ -608,7 +638,7 @@ class TrailingSLTaker:
         
 
             
-    def set_stop_loss(self, symbol, position, stop_loss_price=None , ord_type='conditional') -> bool:
+    def set_stop_loss(self, symbol, position, stop_loss_price:Decimal=None , ord_type='conditional') -> bool:
         """
         设置止盈单
         :param symbol: 交易对
@@ -618,18 +648,18 @@ class TrailingSLTaker:
         :return: 是否成功设置止盈单
         """
         # 计算下单数量
-        amount = abs(float(position['contracts']))
+        amount = abs(self.toDecimal(position['contracts']))
     
         if amount <= 0:
             self.logger.warning(f"{symbol}: amount is 0 for {symbol}")
             return
 
         # 止损单逻辑 
-        adjusted_price = self.round_price_to_tick(symbol, stop_loss_price)
+        adjusted_price = self.format_price(symbol, stop_loss_price)
         
         # 默认市价止损，委托价格为-1时，执行市价止损。
         sl_params = {
-            'slTriggerPx':str(adjusted_price) , 
+            'slTriggerPx':adjusted_price , 
             'slOrdPx':'-1', # 委托价格为-1时，执行市价止损
             # 'slOrdPx' : adjusted_price,
             'slTriggerPxType':'last',
@@ -695,17 +725,26 @@ class TrailingSLTaker:
 
 
     def calculate_sl_price_by_pct(self, symbol, position, sl_pct) -> Decimal:
+        # 根据持仓方向计算止损价格
         side = position['side']
-        if side == 'long':           
-            sl_price = position['entryPrice'] * (1 - sl_pct/100)  
-            
-        elif side == 'short':        
-            sl_price = position['entryPrice'] * (1 + sl_pct/100)
-       
+        
+        # 使用decimal进行精确计算
+        sl_pct_decimal = self.toDecimal(sl_pct) / 100
+        entry_price_decimal = self.toDecimal(position['entryPrice'])
+        
+        if side == 'long':
+            # 多仓止损价 = 开仓价 * (1 - 止损百分比)
+            sl_price = entry_price_decimal * (1 - sl_pct_decimal)
+        elif side == 'short':
+            # 空仓止损价 = 开仓价 * (1 + 止损百分比) 
+            sl_price = entry_price_decimal * (1 + sl_pct_decimal)
+        else:
+            raise ValueError(f"无效的持仓方向: {side}")
             
+        # 将止损价格四舍五入到合法的价格精度
         sl_order_price = self.round_price_to_tick(symbol, sl_price)
         
-        return sl_order_price   
+        return sl_order_price
             
     def set_global_stop_loss(self, symbol, position, pair_config , stop_loss_pct=None, kLines=None) -> bool:
         """设置全局止损
@@ -716,8 +755,9 @@ class TrailingSLTaker:
             pair_config: 交易对配置
             
         """
+        global_sl_price = self.global_symbol_stop_loss_price.get(symbol, 0.0)
         # 如果已经触发过全局止损并且有止损单，则跳过
-        self.logger.debug(f"{symbol} : 是否设置过全局止损 {self.global_symbol_stop_loss_flag.get(symbol, False)} global_sl_price={self.global_symbol_stop_loss_price.get(symbol, 0.0)}")  
+        self.logger.debug(f"{symbol} : 是否设置过全局止损 {self.global_symbol_stop_loss_flag.get(symbol, False)} global_sl_price={self.format_price(symbol, global_sl_price)}")  
         if self.global_symbol_stop_loss_flag.get(symbol, False):
             return
       
@@ -729,46 +769,55 @@ class TrailingSLTaker:
         side = position['side']       
             
         sl_order_price = self.calculate_sl_price_by_pct(symbol, position, stop_loss_pct)
-        # tp_order_price = float(self.round_price_to_tick(symbol, tp_price))
-        
+
+        precision = self.get_precision_length(symbol)
         # 验证止损价格是否合理20250312
-        mark_price = float(position['markPrice'])
+        mark_price = self.toDecimal(position['markPrice'])
         # 验证止损价格是否合理,如果止损价格已经触发则直接平仓
         if (side == 'long' and sl_order_price >= mark_price) or \
            (side == 'short' and sl_order_price <= mark_price):
             self.close_all_positions(symbol, position)
             direction = "多头" if side == "long" else "空头"
-            self.logger.warning(f"{symbol}: !! {direction}止损价格= {sl_order_price} {'大于等于' if side=='long' else '小于等于'}市场价格= {mark_price}，触发止损")
+            self.logger.warning(f"{symbol}: !! {direction}止损价格= {sl_order_price:.{precision}} {'大于等于' if side=='long' else '小于等于'}市场价格= {mark_price:.{precision}}，触发止损")
             return
                 
         # 250228 没有指定止损回撤阈值stop_loss_pct...
         open_swing_point = pair_config.get('open_swing_point', False)
         if open_swing_point :
             if kLines is None :
-                klines_period = str(pair_config.get('klines_period', '1m'))
+                klines_period = str(pair_config.get('CHF', '1m'))
                 kLines = self.get_historical_klines(symbol=symbol,bar=klines_period)               
        
             swing_points_length = pair_config.get('swing_points_length', 20)
             isolated_points = self.get_last_solated_point(symbol ,position , kLines,prd=swing_points_length)  
-        
+            # self.logger.debug(f"--------00 {isolated_points[0]['high']}" )
             if len(isolated_points) > 0 :
+                # 获取最近的孤立点
                 last_isolated_point = isolated_points[0]
-                                    
-                # 多头仓位，取孤立点的低点和原止损价的最小值作为新的止损价
-                if side == 'long':
-                    sl_order_price = min(last_isolated_point['low'], sl_order_price)
-                # 空头仓位，取孤立点的高点和原止损价的最大值作为新的止损价 
-                else:
-                    sl_order_price = max(last_isolated_point['high'], sl_order_price)
-                    
-                self.logger.debug(f"{symbol} : {side} 止损价={sl_order_price} 孤立点=\n{last_isolated_point} ")
-
+                
+                # 将孤立点价格转换为Decimal类型
+                isolated_high = self.toDecimal(last_isolated_point['high'])
+                isolated_low = self.toDecimal(last_isolated_point['low'])
+                
+                # 根据持仓方向设置止损价格
+                sl_order_price = (
+                    min(isolated_low, sl_order_price) if side == 'long'
+                    else max(isolated_high, sl_order_price)
+                )
+                
+                # 记录日志
+                self.logger.debug(
+                    f"{symbol} : {side} 止损价={sl_order_price:.{precision}} \n"
+                    f"孤立点高点={isolated_high:.{precision}} \n"
+                    f"孤立点低点={isolated_low:.{precision}}"
+                )
 
         
         last_sl_price= self.global_symbol_stop_loss_price.get(symbol,0.0)  
         if last_sl_price != 0.0 and last_sl_price == sl_order_price:
             self.global_symbol_stop_loss_flag[symbol] = True
-            self.logger.debug(f"{symbol} : [{side}] 全局止损价没变化, {last_sl_price} = {sl_order_price}")
+            self.logger.debug(f"{symbol} : [{side}] 全局止损价没变化, {last_sl_price:.{precision}} = {sl_order_price:.{precision}}")
+            
             return 
             
         try:
@@ -781,7 +830,7 @@ class TrailingSLTaker:
             )
             if if_success:
                 # 设置全局止损标志
-                self.logger.info(f"{symbol} : [{side}] 设置全局止损价={sl_order_price}")
+                self.logger.info(f"{symbol} : [{side}] 设置全局止损价={sl_order_price:.{precision}}")
                 self.global_symbol_stop_loss_flag[symbol] = True
                 self.global_symbol_stop_loss_price[symbol] = sl_order_price
                 
@@ -793,50 +842,90 @@ class TrailingSLTaker:
             traceback.print_exc()
             self.send_feishu_notification(error_msg)  
     
-    def calculate_take_profile_price(self, symbol, position, take_profile_pct, offset=1) -> Decimal:
+    def calculate_take_profile_price(self, symbol: str, position: dict, take_profile_pct: float, offset: int = 1) -> Decimal:
+        """计算止盈价格
+        Args:
+            symbol: 交易对
+            position: 持仓信息
+            take_profile_pct: 止盈百分比
+            offset: 价格偏移量
+        Returns:
+            Decimal: 止盈价格
+        """
+        # 获取最小价格变动单位和开仓价格
         tick_size = self.get_tick_size(symbol)
-
-        entry_price = position['entryPrice']
+        
+        # 获取开仓价格并转换为Decimal类型
+        entry_price = self.toDecimal(position['entryPrice'])
+        
+        # 获取持仓方向
         side = position['side']
 
-        # 计算止盈价格。
-
-        if side == 'long':
-            take_profile_price = Decimal(entry_price * (1+take_profile_pct/100)) - offset * tick_size
-
-
-        elif side == 'short':
+        # 将止盈百分比转换为小数形式的Decimal
+        take_profile_pct = self.toDecimal(take_profile_pct) / 100
         
-            # base_price = entry_price * (1-take_profile_pct)
-            take_profile_price = Decimal(entry_price * (1-take_profile_pct/100)) + offset * tick_size
-     
-        return Decimal(self.round_price_to_tick(symbol,take_profile_price))
+        # 计算价格偏移量
+        price_offset = offset * tick_size
+        
+        # 根据持仓方向计算基础止盈价格
+        # 多仓: 开仓价 * (1 + 止盈率)
+        # 空仓: 开仓价 * (1 - 止盈率) 
+        base_price = entry_price * (
+            1 + take_profile_pct if side == 'long' 
+            else 1 - take_profile_pct
+        )
+        
+        # 应用偏移量调整最终止盈价格
+        # 多仓: 基础价格 - 偏移量
+        # 空仓: 基础价格 + 偏移量
+        take_profile_price = (
+            base_price - price_offset if side == 'long' 
+            else base_price + price_offset
+        )
+
+        # 按照价格精度四舍五入并返回
+        return self.round_price_to_tick(symbol, take_profile_price)
     
     # 计算回撤止盈价格
-    def calculate_stop_loss_price(self, symbol, position, stop_loss_pct, offset=1) -> float:
+    def calculate_stop_loss_price(self, symbol, position, stop_loss_pct, offset=1) -> Decimal:
         tick_size = self.get_tick_size(symbol)
-        market_price = position['markPrice']
-        entry_price = position['entryPrice']
+        market_price = self.toDecimal(position['markPrice'])
+        entry_price = self.toDecimal(position['entryPrice'])
         side = position['side']
         # base_price = abs(market_price-entry_price) * (1-stop_loss_pct)
         # 计算止盈价格，用市场价格（取持仓期间历史最高）减去开仓价格的利润，再乘以不同阶段的止盈百分比。
-        latest_stop_loss_price = self.exchange.safe_float(self.global_symbol_stop_loss_price,symbol,None)
+        latest_stop_loss_price = self.toDecimal(self.global_symbol_stop_loss_price.get(symbol,None))
+        # 多头仓位止损价计算
         if side == 'long':
-            last_max_market_price = self.max_market_price.get(symbol,0.0)
-            self.max_market_price[symbol] = max(market_price,last_max_market_price)
-            base_price = abs(self.max_market_price[symbol] - entry_price) * (1-stop_loss_pct)
-            stop_loss_price = Decimal(entry_price + base_price) - offset * tick_size
-            if latest_stop_loss_price :
-                stop_loss_price = max(stop_loss_price,latest_stop_loss_price)
+            # 获取并更新最高价
+            last_max_market_price = self.toDecimal(self.max_market_price.get(symbol, 0.0))
+            self.max_market_price[symbol] = max(market_price, last_max_market_price)
+            
+            # 计算基准价格和止损价格
+            price_diff = abs(self.max_market_price[symbol] - entry_price)
+            base_price = price_diff * self.toDecimal(1 - stop_loss_pct) 
+            stop_loss_price = entry_price + base_price - offset * tick_size
+            
+            # 如果已有止损价,取较高值
+            if latest_stop_loss_price:
+                stop_loss_price = max(stop_loss_price, latest_stop_loss_price)
 
+        # 空头仓位止损价计算
         elif side == 'short':
-            last_min_market_price = self.min_market_price.get(symbol,float('inf'))
-            self.min_market_price[symbol] = min(market_price,last_min_market_price)
-            base_price = abs(self.min_market_price[symbol] - entry_price) * (1-stop_loss_pct)
-            stop_loss_price = Decimal(entry_price - base_price) + offset * tick_size
-            if latest_stop_loss_price :
-                stop_loss_price = min(stop_loss_price,latest_stop_loss_price)
-        return float(self.round_price_to_tick(symbol,stop_loss_price))
+            # 获取并更新最低价
+            last_min_market_price = self.toDecimal(self.min_market_price.get(symbol, float('inf')))
+            self.min_market_price[symbol] = min(market_price, last_min_market_price)
+            
+            # 计算基准价格和止损价格
+            price_diff = abs(self.min_market_price[symbol] - entry_price)
+            base_price = price_diff * self.toDecimal(1 - stop_loss_pct)
+            stop_loss_price = entry_price - base_price + offset * tick_size
+            
+            # 如果已有止损价,取较低值
+            if latest_stop_loss_price:
+                stop_loss_price = min(stop_loss_price, latest_stop_loss_price)
+                
+        return self.round_price_to_tick(symbol,stop_loss_price)
     
     # 市价仓位平仓    
     def close_all_positions(self,symbol,position):
@@ -911,7 +1000,8 @@ class TrailingSLTaker:
     
     def check_position(self, symbol, position):
         # 清理趋势相反的仓位
-        pair_config = self.trading_pairs_config.get(symbol, {})
+        # pair_config = self.trading_pairs_config.get(symbol, {})
+        pair_config = self.get_pair_config(symbol)
         self.check_reverse_position(symbol=symbol, position=position, pair_config=pair_config)
         
         # 检查止损是否触发止盈
@@ -926,8 +1016,16 @@ class TrailingSLTaker:
         """
     
         total_profit = self.calculate_average_profit(symbol, position)
+
+        # 获取开仓价和市价,转为Decimal类型提高精度
+        entry_price = self.toDecimal(position['entryPrice'])
+        mark_price = self.toDecimal(position['markPrice'])
+        precision = self.get_precision_length(symbol)
         
-        msg = f"{symbol}: 盈利= {total_profit:.2f}% 开仓= {position['entryPrice']:.10f} 市价= {position['markPrice']:.10f}"
+        # 格式化消息,使用f-string提高可读性
+        msg = (f"{symbol}: 盈利={total_profit:.2f}% "
+               f"开仓={entry_price:.{precision}f} "
+               f"市价={mark_price:.{precision}f}")
         self.logger.info(msg)
         self.send_feishu_notification(msg)
             
@@ -1002,9 +1100,9 @@ class TrailingSLTaker:
             )
             
             # 检查价格是否变化
-            latest_sl_price = self.exchange.safe_float(self.global_symbol_stop_loss_price, symbol, 0.0)
+            latest_sl_price = self.toDecimal(self.global_symbol_stop_loss_price.get(symbol, 0.0))
             if sl_price == latest_sl_price:
-                self.logger.debug(f"{symbol}: 回撤止损价格{latest_sl_price}未变化，不设置")
+                self.logger.debug(f"{symbol}: 回撤止损价格{latest_sl_price:.{precision}}未变化，不设置")
                 return
                 
             # 设置止损
@@ -1018,8 +1116,8 @@ class TrailingSLTaker:
                 
                 # 发送通知
                 msg = (f"{symbol}: 盈利达到【{current_tier}】阈值，最高总盈利: {cur_highest_total_profit:.2f}%,"
-                      f"当前盈利回撤到: {total_profit:.2f}%，市场价格:{position['markPrice']},"
-                      f"设置回撤止损位: {sl_price:.9f}")
+                      f"当前盈利回撤到: {total_profit:.2f}%，市场价格:{mark_price:.{precision}},"
+                      f"设置回撤止损位: {sl_price:.{precision}}")
                 self.logger.info(msg)
                 self.send_feishu_notification(msg)
                 
@@ -1074,15 +1172,16 @@ class TrailingSLTaker:
 
                 for position in positions:
                     symbol = position['symbol']
-                    cur_entry_price = position['entryPrice']
-                    # 检查仓位是否有变化 TODO 永远不会执行。
+                    cur_entry_price = self.toDecimal(position['entryPrice'])
+                   
                     if symbol in self.positions_entry_price and cur_entry_price != self.positions_entry_price[symbol]:
                         # 新开仓
                         self.reset_all_cache(symbol)
                     
                     if symbol not in self.positions_entry_price:
                         self.positions_entry_price[symbol] = cur_entry_price
-                        msg = f"{symbol} : ## 重新开仓。 入场方向={position['side']} 入场价格={cur_entry_price} ##"
+                        precision = self.get_precision_length(symbol)
+                        msg = f"{symbol} : ## 重新开仓。 入场方向={position['side']} 入场价格={cur_entry_price:.{precision}} ##"
                         self.logger.info(msg)
                         self.send_feishu_notification(msg)