fixing order issues

hbot.py

@@ -252,6 +252,15 @@ class HyperliquidAPI:
             logger.error(f"Size rounded to zero for {coin} (sz_dec={sz_dec}). Skipping.")
             return None
 
+        # ── Check notional after rounding ───────────────────────────────────
+        notional_after_rounding = sz * px
+        if notional_after_rounding < 10.0:
+            logger.error(
+                f"[{coin}] Notional ${notional_after_rounding:.2f} falls below $10 after rounding "
+                f"(sz={sz}, px={px:.{px_dec}f}). Skipping."
+            )
+            return None
+
         limit_px = round(px * 1.02, px_dec)
         logger.info(f"Placing {'BUY' if is_buy else 'SELL'} limit-IOC {sz} {coin} @ {limit_px} (mark={round(px, px_dec)}) [px_dec={px_dec} sz_dec={sz_dec}]")
 
@@ -372,7 +381,7 @@ class HyperliquidAPI:
                         Guarantees a fill but pays taker fee.
                         Best for fast strategies (scalp 15m/30m, hype).
 
-          "none"      — log the rejection and give up (original behaviour).
+            "none"      — log the rejection and give up (original behaviour).
         """
         sz_dec = self.get_sz_decimals(coin)
         px_dec = self.get_px_decimals(coin)
@@ -380,6 +389,16 @@ class HyperliquidAPI:
         if sz <= 0:
             logger.error(f"Size rounded to zero for {coin}. Skipping.")
             return None
+
+        # ── Check notional after rounding ───────────────────────────────────
+        notional_after_rounding = sz * px
+        if notional_after_rounding < 10.0:
+            logger.error(
+                f"[{coin}] Notional ${notional_after_rounding:.2f} falls below $10 after rounding "
+                f"(sz={sz}, px={px:.{px_dec}f}). Skipping."
+            )
+            return None
+
         limit_px = round(float(px), px_dec)
 
         tif = "Alo" if post_only else "Gtc"

strategy_mean_reversion_zscore.py

@@ -3,14 +3,15 @@
 Strategy: Z-Score Mean Reversion (1h)
 =====================================
 This strategy identifies extreme price deviations from the mean (20-period SMA)
-and trades the reversion back to that mean.
+and trades the reversion back to that mean, with 200 EMA directional filter.
 
 Core Logic:
 - Z-Score: (Close - SMA) / StdDev. Measures how many standard deviations price is from the mean.
-- Entry (Long): Z-Score < -2.0 (Oversold extreme).
-- Entry (Short): Z-Score > 2.0 (Overbought extreme).
+- Entry (Long): Z-Score < -1.5 (Oversold) AND Price > 200 EMA (reversion in uptrend).
+- Entry (Short): Z-Score > 1.5 (Overbought) AND Price < 200 EMA (reversion in downtrend).
 - Exit: Price hits the SMA (Z-Score returns to 0) or Stop Loss is hit.
-- Filter: ADX < 25 (Market should NOT be strongly trending).
+- Filter: ADX < 30 (avoid strong trends), 200 EMA for trend direction.
+- Philosophy: Trade extreme reversals only in the direction of the longer-term trend.
 """
 
 from __future__ import annotations
@@ -59,24 +60,27 @@ class StrategyEngine:
         return d.dropna()
 
     def signal_for_row(self, row: pd.Series) -> int:
-        z = float(row["zscore"])
-        adx = float(row["adx"])
-        close = float(row["close"])
-        ema200 = float(row["ema200"])
-        
-        # Only trade in moderately trending or ranging markets
-        if adx > 30:
-            return 0
-            
-        # LONG: Z-Score below -1.5 AND price above EMA200 (reversion in uptrend)
-        if z < -1.5 and close > ema200:
-            return 1
-            
-        # SHORT: Z-Score above 1.5 AND price below EMA200 (reversion in downtrend)
-        if z > 1.5 and close < ema200:
-            return -1
-            
-        return 0
+         z = float(row["zscore"])
+         adx = float(row["adx"])
+         close = float(row["close"])
+         ema200 = float(row["ema200"])
+
+         # Only trade in moderately trending or ranging markets
+         if adx > 30:
+             return 0
+
+         # ── 200 EMA directional filter (only trade extreme reversion in direction of trend) ──
+         # LONG only if z-score is BELOW -1.5 AND price is ABOVE 200 EMA (reversion in uptrend)
+         # This avoids catching falling knives in downtrends
+         if z < -1.5 and close > ema200:
+             return 1
+
+         # SHORT only if z-score is ABOVE 1.5 AND price is BELOW 200 EMA (reversion in downtrend)
+         # This avoids catching rallies in uptrends
+         if z > 1.5 and close < ema200:
+             return -1
+
+         return 0
 
     def risk_levels(self, entry: float, atr: float, side: int, atr_pct: float = 0.0, row: Optional[pd.Series] = None) -> Tuple[float, float]:
         # TP is the mean (SMA), which we can approximate as the current entry minus/plus some distance

strategy_rsi_extreme.py

@@ -1,97 +0,0 @@
-#!/usr/bin/env python3
-"""
-Strategy: RSI Extreme Reversal (1h)
-====================================
-Targets "over-extended" markets using multiple RSI timeframes and Bollinger Bands.
-Designed to capture sharp reversals after parabolic moves.
-
-Core Logic:
-- RSI(14) and RSI(2) for dual-speed momentum assessment.
-- Bollinger Bands (20, 2.5) to identify price extremes.
-- Entry (Long): RSI(14) < 30 AND RSI(2) < 10 AND price below Lower BB.
-- Entry (Short): RSI(14) > 70 AND RSI(2) > 90 AND price above Upper BB.
-- Exit: RSI(14) crosses back to the mean (50) or 2:1 RR hit.
-"""
-
-from __future__ import annotations
-from dataclasses import dataclass
-from typing import Dict, Optional, Tuple
-import numpy as np
-import pandas as pd
-import ta
-
-@dataclass
-class TradeIntent:
-    coin: str
-    timeframe: str
-    side: str
-    entry_price: float
-    stop_loss: float
-    take_profit: float
-    confidence: float
-
-class StrategyEngine:
-    def __init__(self, config: Dict):
-        self.config = config
-        self.use_maker_orders = False
-        
-    def add_indicators(self, df: pd.DataFrame) -> pd.DataFrame:
-        d = df.copy()
-        
-        # RSI 14 and 2
-        d["rsi14"] = ta.momentum.RSIIndicator(d["close"], window=14).rsi()
-        d["rsi2"]  = ta.momentum.RSIIndicator(d["close"], window=2).rsi()
-        
-        # Bollinger Bands (20, 2.5)
-        bb = ta.volatility.BollingerBands(d["close"], window=20, window_dev=2.5)
-        d["bb_high"] = bb.bollinger_hband()
-        d["bb_low"] = bb.bollinger_lband()
-        
-        # ATR for risk
-        d["atr"] = ta.volatility.AverageTrueRange(d["high"], d["low"], d["close"], window=14).average_true_range()
-        d["atr_pct"] = d["atr"] / d["close"] * 100
-        
-        return d.dropna()
-
-    def signal_for_row(self, row: pd.Series) -> int:
-        close = float(row["close"])
-        rsi14 = float(row["rsi14"])
-        rsi2 = float(row["rsi2"])
-        bb_high = float(row["bb_high"])
-        bb_low = float(row["bb_low"])
-        
-        # LONG: Deeply oversold on both RSIs + Price below BB Lower
-        if rsi14 < 30 and rsi2 < 10 and close < bb_low:
-            return 1
-            
-        # SHORT: Deeply overbought on both RSIs + Price above BB Upper
-        if rsi14 > 70 and rsi2 > 90 and close > bb_high:
-            return -1
-            
-        return 0
-
-    def risk_levels(self, entry: float, atr: float, side: int, atr_pct: float = 0.0, row: Optional[pd.Series] = None) -> Tuple[float, float]:
-        # Tight 1.5 ATR Stop, 3.5 ATR TP (Aggressive RR for sharp reversals)
-        if side == 1:
-            sl = entry - (1.5 * atr)
-            tp = entry + (3.5 * atr)
-        else:
-            sl = entry + (1.5 * atr)
-            tp = entry - (3.5 * atr)
-        return sl, tp
-
-    def trail_stop(self, side: int, entry: float, current_sl: float, close: float, atr: float) -> float:
-        # Trail more tightly once in profit
-        if side == 1:
-            return max(current_sl, close - (1.5 * atr))
-        else:
-            return min(current_sl, close + (1.5 * atr))
-
-    def build_intent(self, coin: str, timeframe: str, row: pd.Series) -> Optional[TradeIntent]:
-        signal = self.signal_for_row(row)
-        if signal == 0:
-            return None
-        side = "long" if signal == 1 else "short"
-        entry = float(row["close"])
-        stop, tp = self.risk_levels(entry, float(row["atr"]), signal, 0, row)
-        return TradeIntent(coin, timeframe, side, entry, stop, tp, 0.85)

strategy_st_pullback.py

@@ -1,120 +0,0 @@
-#!/usr/bin/env python3
-"""
-Strategy: SuperTrend Pullback (1h)
-==================================
-A trend-following strategy that enters on pullbacks during a confirmed SuperTrend.
-Matches the logic style of 'strategy_hype' and 'strategy_conservative'.
-
-Core Logic:
-- SuperTrend (10, 3.0) for trend direction.
-- RSI (14) for pullback timing.
-- Entry (Long): SuperTrend is UP and RSI < 45 (Pullback in uptrend).
-- Entry (Short): SuperTrend is DOWN and RSI > 55 (Bounce in downtrend).
-- ATR-based stops and targets (1.5:3.0 RR).
-"""
-
-from __future__ import annotations
-from dataclasses import dataclass
-from typing import Dict, Optional, Tuple
-import numpy as np
-import pandas as pd
-import ta
-
-@dataclass
-class TradeIntent:
-    coin: str
-    timeframe: str
-    side: str
-    entry_price: float
-    stop_loss: float
-    take_profit: float
-    confidence: float
-
-class StrategyEngine:
-    def __init__(self, config: Dict):
-        self.config = config
-        self.use_maker_orders = False
-        
-    def add_indicators(self, df: pd.DataFrame) -> pd.DataFrame:
-        d = df.copy()
-        
-        # ATR for SuperTrend and Risk
-        d["atr"] = ta.volatility.AverageTrueRange(d["high"], d["low"], d["close"], window=14).average_true_range()
-        d["atr_pct"] = d["atr"] / d["close"] * 100
-        
-        # RSI 14
-        d["rsi"] = ta.momentum.RSIIndicator(d["close"], window=14).rsi()
-        
-        # SuperTrend (10, 3.0)
-        multiplier = 3.0
-        hl2 = (d["high"] + d["low"]) / 2
-        d["st_upper_basic"] = hl2 + (multiplier * d["atr"])
-        d["st_lower_basic"] = hl2 - (multiplier * d["atr"])
-        
-        upper_band = d["st_upper_basic"].values
-        lower_band = d["st_lower_basic"].values
-        close = d["close"].values
-        
-        final_upper = np.zeros(len(d))
-        final_lower = np.zeros(len(d))
-        direction = np.zeros(len(d))
-        
-        for i in range(1, len(d)):
-            # Upper Band
-            if upper_band[i] < final_upper[i-1] or close[i-1] > final_upper[i-1]:
-                final_upper[i] = upper_band[i]
-            else:
-                final_upper[i] = final_upper[i-1]
-            # Lower Band
-            if lower_band[i] > final_lower[i-1] or close[i-1] < final_lower[i-1]:
-                final_lower[i] = lower_band[i]
-            else:
-                final_lower[i] = final_lower[i-1]
-            # Direction
-            if i == 1: direction[i] = 1
-            elif close[i] > final_upper[i-1]: direction[i] = 1
-            elif close[i] < final_lower[i-1]: direction[i] = -1
-            else: direction[i] = direction[i-1]
-            
-        d["st_direction"] = direction
-        
-        return d.dropna()
-
-    def signal_for_row(self, row: pd.Series) -> int:
-        st_dir = int(row["st_direction"])
-        rsi = float(row["rsi"])
-        
-        # LONG: SuperTrend UP and RSI pulled back below 45
-        if st_dir == 1 and rsi < 45:
-            return 1
-            
-        # SHORT: SuperTrend DOWN and RSI bounced above 55
-        if st_dir == -1 and rsi > 55:
-            return -1
-            
-        return 0
-
-    def risk_levels(self, entry: float, atr: float, side: int, atr_pct: float = 0.0, row: Optional[pd.Series] = None) -> Tuple[float, float]:
-        # 1.5 ATR SL, 3.5 ATR TP (consistent with your successful strategies)
-        if side == 1:
-            sl = entry - (1.5 * atr)
-            tp = entry + (3.5 * atr)
-        else:
-            sl = entry + (1.5 * atr)
-            tp = entry - (3.5 * atr)
-        return sl, tp
-
-    def trail_stop(self, side: int, entry: float, current_sl: float, close: float, atr: float) -> float:
-        if side == 1:
-            return max(current_sl, close - (2.5 * atr))
-        else:
-            return min(current_sl, close + (2.5 * atr))
-
-    def build_intent(self, coin: str, timeframe: str, row: pd.Series) -> Optional[TradeIntent]:
-        signal = self.signal_for_row(row)
-        if signal == 0:
-            return None
-        side = "long" if signal == 1 else "short"
-        entry = float(row["close"])
-        stop, tp = self.risk_levels(entry, float(row["atr"]), signal, 0, row)
-        return TradeIntent(coin, timeframe, side, entry, stop, tp, 0.8)