1052 lines
48 KiB
Python
1052 lines
48 KiB
Python
import asyncio, logging, joblib, time, json, aiohttp, os
|
|
from datetime import datetime, timedelta
|
|
from src.config import get_config
|
|
from src.bot.binance_client import BinanceClientWrapper
|
|
from src.integrations.telegram_notifier import TelegramNotifier
|
|
from src.integrations.obsidian_logger import ObsidianLogger
|
|
from src.strategies.ml_strategy import MLStrategy
|
|
|
|
logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(name)s - %(levelname)s - %(message)s')
|
|
logger = logging.getLogger(__name__)
|
|
|
|
# DASHBOARD CLIENT - MOCK (sends REAL Binance data only via HTTP)
|
|
class DashboardClient:
|
|
"""Send ONLY REAL, VERIFIED trades to dashboard"""
|
|
|
|
async def record_buy(self, pair, qty, price):
|
|
"""Record BUY - VERIFY on Binance first!"""
|
|
try:
|
|
async with aiohttp.ClientSession() as session:
|
|
async with session.post('http://localhost:7000/api/trade/buy', json={
|
|
'pair': pair,
|
|
'qty': qty,
|
|
'price': price,
|
|
'entry_time': datetime.now().isoformat()
|
|
}) as resp:
|
|
if resp.status == 200:
|
|
logger.info(f'✅ Dashboard recorded BUY: {pair}')
|
|
else:
|
|
logger.warning(f'❌ Dashboard BUY record failed: {resp.status}')
|
|
except Exception as e:
|
|
logger.warning(f'Dashboard BUY error: {e}')
|
|
|
|
async def record_sell(self, pair, qty, price, profit_usd, profit_pct, hold_time_min):
|
|
"""Record SELL - ONLY IF REAL!"""
|
|
try:
|
|
async with aiohttp.ClientSession() as session:
|
|
async with session.post('http://localhost:7000/api/trade/sell', json={
|
|
'pair': pair,
|
|
'qty': qty,
|
|
'price': price,
|
|
'profit_usd': profit_usd,
|
|
'profit_pct': profit_pct,
|
|
'hold_time_min': hold_time_min,
|
|
'exit_time': datetime.now().isoformat()
|
|
}) as resp:
|
|
if resp.status == 200:
|
|
logger.info(f'✅ Dashboard recorded SELL: {pair} profit=${profit_usd:.2f}')
|
|
else:
|
|
logger.warning(f'❌ Dashboard SELL record failed: {resp.status}')
|
|
except Exception as e:
|
|
logger.warning(f'Dashboard SELL error: {e}')
|
|
|
|
async def update_state(self, balance, daily_pnl, portfolio_value_usd, total_pnl=0.0, trades_today=0, wins_today=0, losses_today=0):
|
|
"""Update state - REAL DATA ONLY"""
|
|
try:
|
|
portfolio_value_chf = portfolio_value_usd * 0.84
|
|
async with aiohttp.ClientSession() as session:
|
|
async with session.post('http://localhost:7000/api/update', json={
|
|
'balance': balance,
|
|
'daily_pnl': daily_pnl,
|
|
'total_pnl': total_pnl,
|
|
'trades_today': trades_today,
|
|
'wins_today': wins_today,
|
|
'losses_today': losses_today,
|
|
'portfolio_value_usd': portfolio_value_usd,
|
|
'portfolio_value_chf': portfolio_value_chf,
|
|
'last_update': datetime.now().isoformat()
|
|
}) as resp:
|
|
if resp.status != 200:
|
|
logger.warning(f'Dashboard state update failed: {resp.status}')
|
|
except Exception as e:
|
|
logger.debug(f'Dashboard update error: {e}')
|
|
|
|
async def clear_state(self):
|
|
"""Clear dashboard - START FRESH"""
|
|
try:
|
|
async with aiohttp.ClientSession() as session:
|
|
async with session.post('http://localhost:7000/api/clear') as resp:
|
|
logger.info(f'Dashboard cleared: {resp.status}')
|
|
except:
|
|
pass
|
|
|
|
class MLTradingBot:
|
|
def __init__(self, config, binance, telegram, obsidian, model, scaler):
|
|
self.config = config
|
|
self.binance = binance
|
|
self.telegram = telegram
|
|
self.obsidian = obsidian
|
|
self.model = model
|
|
self.scaler = scaler
|
|
self.dashboard = DashboardClient() # ADD THIS
|
|
self.strategy = MLStrategy(trading_pair=config.trading_pair)
|
|
|
|
self.last_report_time = time.time()
|
|
self.report_interval = 10800
|
|
self.trades_today = 0
|
|
self.wins_today = 0
|
|
self.losses_today = 0
|
|
self.daily_pnl = 0.0
|
|
self.report_count = 0
|
|
self.last_swap_time = time.time()
|
|
|
|
# Metriken für echte Win-Rate
|
|
self.total_trades = 0
|
|
self.total_pnl = 0.0
|
|
self.max_drawdown = 0.0
|
|
self.min_daily_pnl = 0.0
|
|
self.starting_capital = 100.0
|
|
self.daily_loss_limit_reached = False
|
|
|
|
# Symbol constraints cache
|
|
self.symbol_info = {}
|
|
self.pairs = ['BTCUSDT', 'ETHUSDT', 'SOLUSDT', 'BNBUSDT', 'XRPUSDT']
|
|
|
|
# Track open positions
|
|
self.open_positions = {} # CLEAN START - reset on bot restart
|
|
|
|
logger.info('🗑️ RESET: Cleared all stored positions (dashboard will show REAL Binance state only)')
|
|
|
|
# Error tracking & resilience
|
|
self.last_error_time = 0
|
|
self.error_threshold = 5
|
|
self.error_count = 0
|
|
self.error_cooldown_until = 0
|
|
|
|
# Daily reset tracking
|
|
self.last_daily_reset = datetime.utcnow().date()
|
|
|
|
async def load_exchange_info(self):
|
|
"""Load LOT_SIZE constraints for all trading pairs"""
|
|
try:
|
|
logger.info('📥 Loading Binance symbol constraints...')
|
|
for pair in self.pairs:
|
|
try:
|
|
info = await self.binance.get_exchange_info(pair)
|
|
if info:
|
|
self.symbol_info[pair] = info
|
|
logger.debug(f'✅ {pair}: minNotional=${info.get("minNotional", 0)}, stepSize={info.get("stepSize", 0)}')
|
|
except Exception as e:
|
|
logger.warning(f'Failed to load {pair}: {e}')
|
|
logger.info(f'✅ Loaded constraints for {len(self.symbol_info)} pairs')
|
|
except Exception as e:
|
|
logger.error(f'Failed to load exchange info: {e}')
|
|
|
|
def calculate_valid_quantity(self, pair: str, usdt_amount: float, price: float) -> float:
|
|
"""Calculate order quantity respecting Binance LOT_SIZE constraints."""
|
|
try:
|
|
if pair not in self.symbol_info:
|
|
logger.warning(f'⚠️ No info for {pair}')
|
|
return 0
|
|
|
|
if price is None or price <= 0:
|
|
logger.warning(f'⚠️ Invalid price for {pair}: {price}')
|
|
return 0
|
|
|
|
info = self.symbol_info[pair]
|
|
step_size = float(info.get('stepSize', 1e-8))
|
|
min_qty = float(info.get('minQty', 0))
|
|
max_qty = float(info.get('maxQty', 1e10))
|
|
min_notional = float(info.get('minNotional', 10))
|
|
|
|
qty = usdt_amount / price
|
|
notional = qty * price
|
|
|
|
# CHECK MINNOTIONAL BEFORE ROUNDING
|
|
if notional < min_notional:
|
|
logger.debug(f'❌ {pair}: notional ${notional:.2f} < min ${min_notional:.2f} (requested ${usdt_amount:.2f})')
|
|
return 0
|
|
|
|
if step_size > 0:
|
|
qty = round(qty / step_size) * step_size
|
|
|
|
# RECHECK NOTIONAL AFTER ROUNDING (rounding might make qty too small!)
|
|
notional_after = qty * price
|
|
if notional_after < min_notional:
|
|
logger.debug(f'❌ {pair}: after rounding notional ${notional_after:.2f} < min ${min_notional:.2f}')
|
|
return 0
|
|
|
|
if qty < min_qty:
|
|
logger.debug(f'❌ {pair}: qty {qty:.8f} < min {min_qty:.8f}')
|
|
return 0
|
|
if qty > max_qty:
|
|
qty = max_qty
|
|
|
|
logger.debug(f'✅ {pair}: qty={qty:.8f} (notional=${notional:.2f})')
|
|
return qty
|
|
except Exception as e:
|
|
logger.error(f'Quantity calculation error: {e}')
|
|
return 0
|
|
|
|
def format_quantity(self, qty: float, step_size: float) -> str:
|
|
"""Format quantity to proper decimal places - STRICTLY NO scientific notation"""
|
|
try:
|
|
if step_size is None or step_size <= 0:
|
|
# Use Decimal for strict formatting
|
|
from decimal import Decimal, ROUND_DOWN
|
|
d = Decimal(str(qty))
|
|
return str(d.quantize(Decimal('0.00000001'), rounding=ROUND_DOWN))
|
|
|
|
if step_size >= 1:
|
|
return str(int(qty))
|
|
|
|
# Force no scientific notation using format string
|
|
from decimal import Decimal, ROUND_DOWN
|
|
|
|
# Determine decimal places from step_size
|
|
step_str = str(step_size)
|
|
if 'e' in step_str.lower():
|
|
# Scientific notation in step_size
|
|
decimal_places = 8
|
|
elif '.' in step_str:
|
|
decimal_places = len(step_str.split('.')[-1])
|
|
else:
|
|
decimal_places = 0
|
|
|
|
decimal_places = max(decimal_places, 1)
|
|
decimal_places = min(decimal_places, 20)
|
|
|
|
# Round down to step_size
|
|
multiplier = 10 ** decimal_places
|
|
rounded_qty = int(qty * multiplier) / multiplier
|
|
|
|
# Format without scientific notation
|
|
formatted = f'{rounded_qty:.{decimal_places}f}'
|
|
|
|
# Validate: no 'e' in result
|
|
if 'e' in formatted.lower():
|
|
logger.error(f'SCIENTIFIC NOTATION DETECTED: {qty} → {formatted}')
|
|
return f'{rounded_qty:.8f}'
|
|
|
|
logger.debug(f'Formatted: {qty} → {formatted} (step={step_size})')
|
|
return formatted
|
|
except Exception as e:
|
|
logger.error(f'Format error: {e}')
|
|
# Fallback: use Decimal
|
|
from decimal import Decimal
|
|
d = Decimal(str(qty))
|
|
return str(d)
|
|
|
|
def increment_error_count(self) -> bool:
|
|
"""Track error frequency — return True if limit reached"""
|
|
self.error_count += 1
|
|
self.last_error_time = time.time()
|
|
|
|
if self.error_count >= self.error_threshold:
|
|
self.error_cooldown_until = time.time() + 300
|
|
logger.warning(f'🛑 Error threshold ({self.error_count}) reached! Pausing 5 minutes.')
|
|
return True
|
|
return False
|
|
|
|
def reset_error_count(self):
|
|
"""Reset error counter if no errors in 60 seconds"""
|
|
if time.time() - self.last_error_time > 60:
|
|
if self.error_count > 0:
|
|
logger.info(f'✅ Error counter reset (was {self.error_count})')
|
|
self.error_count = 0
|
|
|
|
async def liquidate_btc_to_usdt_on_startup(self):
|
|
"""ONE-TIME: Sell all BTC to USDT if USDT is too small"""
|
|
pass # Disabled - use force_liquidate_all instead
|
|
|
|
async def force_liquidate_all(self):
|
|
"""MANUAL LIQUIDATION: Force sell ALL holdings to USDT (Marc can trigger on demand)"""
|
|
logger.warning('🔥 FORCE LIQUIDATION STARTED')
|
|
|
|
results = {}
|
|
try:
|
|
balance = await self.binance.get_balance()
|
|
|
|
# Liquidate BTC (round down to valid LOT_SIZE)
|
|
btc_free = float(balance.get('BTC', {}).get('free', 0))
|
|
if btc_free > 0.00001:
|
|
try:
|
|
btc_qty = int(btc_free * 100000) / 100000
|
|
btc_qty = max(btc_qty, 0.00001)
|
|
logger.info(f'📤 Selling {btc_qty:.8f} BTC')
|
|
result = await self.binance.place_order('BTCUSDT', 'SELL', f'{btc_qty:.8f}', 'MARKET')
|
|
if result:
|
|
results['BTC'] = {'status': result.get('status'), 'qty': btc_qty}
|
|
logger.info(f'✅ BTC SOLD: {result.get("status")}')
|
|
except Exception as e:
|
|
logger.error(f'BTC SELL failed: {e}')
|
|
results['BTC'] = {'error': str(e)[:50]}
|
|
|
|
# Liquidate other holdings
|
|
for asset in ['ETH', 'SOL', 'BNB', 'XRP']:
|
|
qty = float(balance.get(asset, {}).get('free', 0))
|
|
if qty > 0.001:
|
|
try:
|
|
pair = f'{asset}USDT'
|
|
logger.info(f'📤 Selling {qty:.8f} {asset}')
|
|
result = await self.binance.place_order(pair, 'SELL', f'{qty:.8f}', 'MARKET')
|
|
if result:
|
|
results[asset] = {'status': result.get('status'), 'qty': qty}
|
|
logger.info(f'✅ {asset} SOLD: {result.get("status")}')
|
|
except Exception as e:
|
|
logger.error(f'{asset} SELL failed: {e}')
|
|
results[asset] = {'error': str(e)[:50]}
|
|
|
|
await asyncio.sleep(2)
|
|
new_balance = await self.binance.get_balance()
|
|
new_usdt = float(new_balance.get('USDT', {}).get('free', 0))
|
|
logger.warning(f'🔥 LIQUIDATION DONE! New USDT: ${new_usdt:.2f}')
|
|
|
|
return {'status': 'success', 'results': results, 'new_usdt': new_usdt}
|
|
except Exception as e:
|
|
logger.error(f'Liquidation error: {e}')
|
|
return {'status': 'error', 'message': str(e)[:100]}
|
|
|
|
async def auto_swap_holdings_to_usdt(self):
|
|
"""ONE-TIME: Sell all BTC to USDT if USDT is too small"""
|
|
try:
|
|
balance = await self.binance.get_balance()
|
|
btc_free = float(balance.get('BTC', {}).get('free', 0))
|
|
usdt_free = float(balance.get('USDT', {}).get('free', 0))
|
|
btc_price = 62500 # Approximate current price
|
|
|
|
# If BTC > 0.001 AND USDT < $10, LIQUIDATE BTC
|
|
if btc_free > 0.0001 and usdt_free < 10:
|
|
logger.warning(f'🔄 STARTUP LIQUIDATION: Selling {btc_free:.8f} BTC (~${btc_free * btc_price:.2f}) to USDT...')
|
|
|
|
try:
|
|
# Use calculate_valid_quantity to respect LOT_SIZE
|
|
valid_qty = self.calculate_valid_quantity('BTCUSDT', btc_free * btc_price, btc_price)
|
|
|
|
if valid_qty <= 0:
|
|
logger.warning(f'⚠️ BTC qty too small after LOT_SIZE check: {valid_qty}')
|
|
return
|
|
|
|
# IMPORTANT: Don't sell MORE than we actually have!
|
|
valid_qty = min(valid_qty, btc_free)
|
|
logger.info(f'📤 Placing SELL: {valid_qty:.8f} BTC (actual balance: {btc_free:.8f})')
|
|
result = await self.binance.place_order(
|
|
symbol='BTCUSDT',
|
|
side='SELL',
|
|
quantity=f'{valid_qty:.8f}',
|
|
order_type='MARKET'
|
|
)
|
|
|
|
if result and result.get('status') in ['FILLED', 'NEW', 'PARTIALLY_FILLED']:
|
|
logger.info(f'✅ BTC LIQUIDATED! Order ID: {result.get("orderId")}, Status: {result.get("status")}')
|
|
# Wait for balance to update
|
|
await asyncio.sleep(3)
|
|
|
|
new_balance = await self.binance.get_balance()
|
|
new_usdt = float(new_balance.get('USDT', {}).get('free', 0))
|
|
new_btc = float(new_balance.get('BTC', {}).get('free', 0))
|
|
logger.info(f'💰 After liquidation: USDT=${new_usdt:.2f}, BTC={new_btc:.8f}')
|
|
except Exception as e:
|
|
logger.error(f'❌ Liquidation order failed: {type(e).__name__}: {str(e)[:100]}')
|
|
except Exception as e:
|
|
logger.error(f'Liquidation check failed: {e}')
|
|
|
|
async def auto_swap_periodically(self):
|
|
"""Periodically swap small holdings back to USDT for liquidity"""
|
|
try:
|
|
if time.time() - self.last_swap_time < 300:
|
|
return
|
|
|
|
if time.time() < self.error_cooldown_until:
|
|
logger.debug('⏸️ Error cooldown active — skipping swap')
|
|
return
|
|
|
|
balance = await self.binance.get_balance()
|
|
if not balance:
|
|
logger.warning('No balance data for swap')
|
|
return
|
|
|
|
swapped_any = False
|
|
|
|
for asset in ['BTC', 'ETH', 'SOL', 'BNB', 'XRP']:
|
|
try:
|
|
qty = float(balance.get(asset, {}).get('free', 0))
|
|
|
|
if qty <= 0.00001:
|
|
continue
|
|
|
|
pair = f'{asset}USDT'
|
|
|
|
# FIX: Robust price fetching with error handling
|
|
try:
|
|
price = await self.binance.get_ticker_price(pair)
|
|
if price is None or price <= 0:
|
|
logger.warning(f'⚠️ Invalid price for {pair}: {price} — skipping swap')
|
|
continue
|
|
except Exception as e:
|
|
logger.warning(f'Failed to get price for {pair}: {e}')
|
|
continue
|
|
|
|
notional = qty * price
|
|
|
|
# Only swap if in safe range
|
|
if notional < 5 or notional > 15:
|
|
logger.debug(f'⏸️ {pair} notional ${notional:.2f} outside swap range [5-15]')
|
|
continue
|
|
|
|
logger.info(f'🔄 ATTEMPTING SWAP: {qty:.8f} {asset} (${notional:.2f}) → USDT @ ${price:.2f}')
|
|
|
|
try:
|
|
if pair not in self.symbol_info:
|
|
await self.load_exchange_info()
|
|
|
|
if pair not in self.symbol_info:
|
|
logger.warning(f'No symbol info for {pair} — skipping')
|
|
continue
|
|
|
|
step_size = self.symbol_info[pair].get('stepSize', 1e-8)
|
|
qty_str = self.format_quantity(qty, step_size)
|
|
|
|
logger.info(f'📤 Placing SWAP SELL: {qty_str} {pair} @ ${price:.2f}')
|
|
result = await self.binance.place_order(
|
|
symbol=pair,
|
|
side='SELL',
|
|
quantity=qty_str, # Pass STRING
|
|
order_type='MARKET'
|
|
)
|
|
|
|
if result:
|
|
# SWAP Alert disabled — user only wants profit notifications
|
|
pass
|
|
swapped_any = True
|
|
self.error_count = 0 # Reset errors on success
|
|
logger.info(f'✅ SWAP EXECUTED!')
|
|
else:
|
|
logger.warning(f'SWAP order returned no result for {pair}')
|
|
|
|
except Exception as e:
|
|
logger.warning(f'Swap order failed for {asset}: {e}')
|
|
self.increment_error_count()
|
|
continue
|
|
|
|
except Exception as e:
|
|
logger.warning(f'Swap check error for {asset}: {e}')
|
|
continue
|
|
|
|
if swapped_any:
|
|
self.last_swap_time = time.time()
|
|
|
|
except Exception as e:
|
|
logger.error(f'Auto-swap error: {e}')
|
|
|
|
async def check_take_profit(self):
|
|
"""Check all positions for exits"""
|
|
try:
|
|
balance = await self.binance.get_balance()
|
|
if not balance:
|
|
return
|
|
|
|
positions_to_close = []
|
|
|
|
for pair in self.pairs:
|
|
try:
|
|
asset = pair.replace('USDT', '')
|
|
current_qty = float(balance.get(asset, {}).get('free', 0))
|
|
|
|
if current_qty <= 0.00001:
|
|
continue
|
|
|
|
# FIX: Robust price fetching
|
|
try:
|
|
current_price = await self.binance.get_ticker_price(pair)
|
|
if current_price is None or current_price <= 0:
|
|
logger.debug(f'⚠️ Invalid price for {pair}: {current_price}')
|
|
continue
|
|
except Exception as e:
|
|
logger.warning(f'Failed to get price for {pair}: {e}')
|
|
continue
|
|
|
|
if pair not in self.open_positions:
|
|
logger.debug(f'⏭️ {pair} not in open_positions (keys: {list(self.open_positions.keys())})')
|
|
continue
|
|
|
|
pos = self.open_positions[pair]
|
|
buy_price = pos['buy_price']
|
|
buy_qty = pos['qty']
|
|
buy_time = datetime.fromisoformat(pos['buy_time'])
|
|
|
|
profit_pct = ((current_price - buy_price) / buy_price) * 100
|
|
hold_time_minutes = (datetime.now() - buy_time).total_seconds() / 60
|
|
|
|
if profit_pct > pos.get('peak_profit', 0):
|
|
pos['peak_profit'] = profit_pct
|
|
|
|
exit_reason = None
|
|
|
|
# 1. STOP-LOSS
|
|
if profit_pct <= -3.0:
|
|
exit_reason = "STOP_LOSS"
|
|
logger.warning(f'🛑 {pair}: STOP-LOSS triggered! {profit_pct:.2f}%')
|
|
positions_to_close.append((pair, current_qty, current_price, buy_price, buy_qty, profit_pct, exit_reason))
|
|
|
|
# 2. MAX HOLD TIME
|
|
elif hold_time_minutes >= 240:
|
|
exit_reason = "MAX_HOLD_TIMEOUT"
|
|
logger.info(f'⏱️ {pair}: MAX_HOLD_TIME reached! {hold_time_minutes:.0f} min')
|
|
positions_to_close.append((pair, current_qty, current_price, buy_price, buy_qty, profit_pct, exit_reason))
|
|
|
|
# 3. TAKE PROFIT
|
|
elif profit_pct >= 1.0:
|
|
exit_reason = "TAKE_PROFIT"
|
|
logger.info(f'💰 {pair}: TAKE_PROFIT reached! +{profit_pct:.2f}%')
|
|
positions_to_close.append((pair, current_qty, current_price, buy_price, buy_qty, profit_pct, exit_reason))
|
|
|
|
# 4. TRAILING STOP
|
|
elif pos['peak_profit'] >= 1.0:
|
|
trailing_stop_level = pos['peak_profit'] - 0.4
|
|
if profit_pct <= trailing_stop_level:
|
|
exit_reason = "TRAILING_STOP"
|
|
logger.info(f'📉 {pair}: TRAILING_STOP triggered! Peak: {pos["peak_profit"]:.2f}%, Current: {profit_pct:.2f}%')
|
|
positions_to_close.append((pair, current_qty, current_price, buy_price, buy_qty, profit_pct, exit_reason))
|
|
|
|
except Exception as e:
|
|
logger.warning(f'Check exit for {pair} failed: {e}')
|
|
continue
|
|
|
|
# Execute all closes
|
|
for pair, current_qty, current_price, buy_price, buy_qty, profit_pct, exit_reason in positions_to_close:
|
|
try:
|
|
# Format quantity BEFORE placing order (keep as STRING!)
|
|
if pair in self.symbol_info:
|
|
step_size = self.symbol_info[pair].get('stepSize', 1e-8)
|
|
qty_str = self.format_quantity(current_qty, step_size)
|
|
else:
|
|
qty_str = f'{current_qty:.8f}'
|
|
|
|
logger.info(f'📤 Placing EXIT order: {qty_str} {pair} (Reason: {exit_reason})')
|
|
result = await self.binance.place_order(
|
|
symbol=pair,
|
|
side='SELL',
|
|
quantity=qty_str, # Pass STRING
|
|
order_type='MARKET'
|
|
)
|
|
|
|
if result and result.get('status') in ['FILLED', 'NEW', 'PARTIALLY_FILLED']:
|
|
# ONLY record if order was actually EXECUTED
|
|
profit_usd = (current_qty * current_price) - (buy_qty * buy_price)
|
|
self.daily_pnl += profit_usd
|
|
self.total_pnl += profit_usd
|
|
self.total_trades += 1
|
|
|
|
if profit_pct >= 0:
|
|
self.wins_today += 1
|
|
icon = "✅"
|
|
else:
|
|
self.losses_today += 1
|
|
icon = "❌"
|
|
|
|
# Only send Telegram alert if PROFITABLE (profit_pct >= 0)
|
|
if profit_pct >= 0:
|
|
await self.telegram.send_alert(
|
|
f'{icon} CLOSED {exit_reason}\n'
|
|
f'{pair}: {current_qty:.8f} @ ${current_price:.2f}\n'
|
|
f'Profit: ${profit_usd:+.2f} ({profit_pct:+.2f}%)\n'
|
|
f'Hold: {(datetime.now() - datetime.fromisoformat(self.open_positions[pair]["buy_time"])).total_seconds() / 60:.0f} min'
|
|
)
|
|
else:
|
|
logger.info(f'Loss trade skipped from Telegram (visible on dashboard): {profit_pct:.2f}%')
|
|
|
|
if self.daily_pnl < self.min_daily_pnl:
|
|
self.min_daily_pnl = self.daily_pnl
|
|
if abs(self.min_daily_pnl) > self.max_drawdown:
|
|
self.max_drawdown = abs(self.min_daily_pnl)
|
|
|
|
self.error_count = 0
|
|
|
|
# Send to dashboard BEFORE deleting position (ONLY for REAL executed trades!)
|
|
hold_time_s = (datetime.now() - datetime.fromisoformat(self.open_positions[pair]["buy_time"])).total_seconds()
|
|
hold_time_min = hold_time_s / 60
|
|
await self.dashboard.record_sell(pair, current_qty, current_price, profit_usd, profit_pct, hold_time_min)
|
|
|
|
del self.open_positions[pair]
|
|
logger.info(f'✅ EXIT EXECUTED & RECORDED TO DASHBOARD!')
|
|
else:
|
|
logger.warning(f'❌ EXIT order FAILED or returned no result for {pair} - NOT recording')
|
|
|
|
except Exception as e:
|
|
logger.warning(f'Exit order failed for {pair}: {e}')
|
|
continue
|
|
|
|
except Exception as e:
|
|
logger.error(f'Take profit check error: {e}')
|
|
|
|
async def find_best_trade(self):
|
|
"""Scan multiple pairs for best signal"""
|
|
try:
|
|
best_signal = {'pair': None, 'signal': 'HOLD'}
|
|
|
|
for pair in self.pairs:
|
|
try:
|
|
# FIX: Robust price fetching
|
|
try:
|
|
price = await self.binance.get_ticker_price(pair)
|
|
if price is None or price <= 0:
|
|
logger.debug(f'⚠️ Invalid price for {pair}: {price}')
|
|
continue
|
|
except Exception as e:
|
|
logger.debug(f'{pair} price fetch failed: {e}')
|
|
continue
|
|
|
|
# Get signal
|
|
try:
|
|
signal = self.strategy.predict(price) if hasattr(self.strategy, 'predict') else 'BUY'
|
|
except Exception as e:
|
|
logger.debug(f'{pair} signal generation failed: {e}')
|
|
signal = 'HOLD'
|
|
|
|
if signal == 'BUY':
|
|
logger.info(f'🟢 BUY signal: {pair} at ${price:.2f}')
|
|
return {'pair': pair, 'price': price, 'signal': signal}
|
|
|
|
except Exception as e:
|
|
logger.debug(f'{pair} scan failed: {e}')
|
|
continue
|
|
|
|
return best_signal
|
|
|
|
except Exception as e:
|
|
logger.error(f'Find trade error: {e}')
|
|
return {'pair': None, 'signal': 'HOLD'}
|
|
|
|
async def monitor_trades(self):
|
|
"""Main trade monitoring with error handling"""
|
|
try:
|
|
self.reset_error_count()
|
|
|
|
if time.time() < self.error_cooldown_until:
|
|
logger.info('⏸️ ERROR COOLDOWN ACTIVE — pausing 5 minutes')
|
|
return
|
|
|
|
# 1. Check for SELL opportunities
|
|
await self.check_take_profit()
|
|
|
|
# 2. Periodically swap small holdings
|
|
await self.auto_swap_periodically()
|
|
|
|
# 3. Get balance
|
|
try:
|
|
balance = await self.binance.get_balance()
|
|
except Exception as e:
|
|
logger.error(f'Balance fetch failed: {e}')
|
|
self.increment_error_count()
|
|
return
|
|
|
|
usdt = float(balance.get('USDT', {}).get('free', 0)) if balance else 0
|
|
|
|
# DEBUG: Log FULL balance
|
|
logger.info(f'💰 Full Balance Breakdown:')
|
|
for asset, amounts in balance.items():
|
|
free = float(amounts.get('free', 0))
|
|
locked = float(amounts.get('locked', 0))
|
|
if free > 0 or locked > 0:
|
|
logger.info(f' {asset}: FREE={free:.8f}, LOCKED={locked:.8f}, TOTAL={free+locked:.8f}')
|
|
self.starting_capital = usdt
|
|
logger.info(f'📊 Starting capital set: ${self.starting_capital:.2f}')
|
|
|
|
logger.info(f'💰 Balance: {usdt:.2f} USDT | Daily P&L: ${self.daily_pnl:.2f}')
|
|
|
|
# 4. Check DAILY LOSS LIMIT
|
|
daily_loss_pct = (self.daily_pnl / self.starting_capital) * 100 if self.starting_capital > 0 else 0
|
|
|
|
if daily_loss_pct <= -5.0:
|
|
self.daily_loss_limit_reached = True
|
|
logger.warning(f'🛑 Daily loss limit reached! ({daily_loss_pct:.1f}%) Pausing.')
|
|
await self.telegram.send_alert(
|
|
f'🛑 Daily Loss Limit reached!\n'
|
|
f'P&L: ${self.daily_pnl:.2f} ({daily_loss_pct:.1f}%)\n'
|
|
f'Bot paused until Midnight UTC'
|
|
)
|
|
return
|
|
|
|
# Reset at midnight UTC
|
|
now = datetime.utcnow()
|
|
if now.date() > self.last_daily_reset:
|
|
self.daily_loss_limit_reached = False
|
|
self.daily_pnl = 0.0
|
|
self.min_daily_pnl = 0.0
|
|
self.trades_today = 0
|
|
self.wins_today = 0
|
|
self.losses_today = 0
|
|
self.last_daily_reset = now.date()
|
|
logger.info('🔄 Daily metrics reset at Midnight UTC')
|
|
await self.telegram.send_alert('🔄 Daily reset complete — trading resumed')
|
|
|
|
# 5. Find BUY signal
|
|
if self.daily_loss_limit_reached:
|
|
logger.info('⏸️ BUY orders paused (loss limit)')
|
|
return
|
|
|
|
try:
|
|
trade = await self.find_best_trade()
|
|
except Exception as e:
|
|
logger.error(f'Find trade error: {e}')
|
|
self.increment_error_count()
|
|
return
|
|
|
|
if trade['signal'] == 'BUY' and usdt >= 5:
|
|
pair = trade['pair']
|
|
price = trade['price']
|
|
|
|
# Use ALL available capital (not just 50%!) to maximize first trade
|
|
order_amount = usdt # Use 100% capital
|
|
qty = self.calculate_valid_quantity(pair, order_amount, price)
|
|
|
|
if qty <= 0:
|
|
logger.debug(f'⚠️ No valid quantity for {pair}')
|
|
return
|
|
|
|
notional = qty * price
|
|
logger.info(f'📈 Order: {qty:.8f} {pair} @ ${price:.2f} = ${notional:.2f}')
|
|
|
|
# SKIP if notional is too small (Binance minimum ~$5 for testing)
|
|
if notional < 5:
|
|
logger.warning(f'⏭️ SKIP {pair}: notional ${notional:.2f} < $5 minimum')
|
|
return
|
|
|
|
try:
|
|
# Format quantity BEFORE passing to API (keep as STRING!)
|
|
if pair in self.symbol_info:
|
|
step_size = self.symbol_info[pair].get('stepSize', 1e-8)
|
|
qty_str = self.format_quantity(qty, step_size) # STRING!
|
|
else:
|
|
qty_str = f'{qty:.8f}'
|
|
|
|
logger.info(f'📤 Placing BUY: {qty_str} {pair} @ ${price:.2f}')
|
|
try:
|
|
result = await self.binance.place_order(
|
|
symbol=pair,
|
|
side='BUY',
|
|
quantity=qty_str, # Pass STRING
|
|
order_type='MARKET'
|
|
)
|
|
logger.info(f'✅ Order result: {result}')
|
|
except Exception as e:
|
|
logger.error(f'❌ Order FAILED: {type(e).__name__}: {str(e)}')
|
|
result = None
|
|
|
|
# ONLY RECORD if order was SUCCESSFUL
|
|
if result and result.get('status') in ['FILLED', 'NEW', 'PARTIALLY_FILLED']:
|
|
logger.info(f'🔍 DEBUG: Storing BUY position {pair}: qty={qty}, price={price}')
|
|
self.open_positions[pair] = {
|
|
'qty': qty,
|
|
'buy_price': price,
|
|
'buy_time': datetime.now().isoformat(),
|
|
'peak_profit': 0.0,
|
|
'trailing_stop': None,
|
|
'order_id': result.get('orderId', 'unknown')
|
|
}
|
|
logger.info(f'🔍 DEBUG: After storage, open_positions keys = {list(self.open_positions.keys())}')
|
|
|
|
self.trades_today += 1
|
|
self.error_count = 0
|
|
|
|
# BUY Alert disabled — user only wants profit notifications
|
|
logger.info(f'✅ BUY FILLED & RECORDED! Order ID: {result.get("orderId", "unknown")}')
|
|
|
|
# Send to dashboard
|
|
await self.dashboard.record_buy(pair, qty, price)
|
|
else:
|
|
# Order FAILED - do NOT record
|
|
logger.warning(f'❌ Order REJECTED or FAILED - NOT recording in open_positions')
|
|
|
|
except Exception as e:
|
|
logger.error(f'Trade execution failed: {e}')
|
|
if self.increment_error_count():
|
|
await self.telegram.send_alert('🛑 Too many errors! Bot paused 5 minutes')
|
|
|
|
except Exception as e:
|
|
logger.error(f'Monitor error: {e}')
|
|
self.increment_error_count()
|
|
|
|
async def send_performance_report(self):
|
|
"""Send detailed 3-hourly report"""
|
|
try:
|
|
self.report_count += 1
|
|
|
|
balance = await self.binance.get_balance()
|
|
usdt = float(balance.get('USDT', {}).get('free', 0)) if balance else 0
|
|
|
|
total_assets_usd = usdt
|
|
for asset in ['BTC', 'ETH', 'SOL', 'BNB', 'XRP']:
|
|
try:
|
|
qty = float(balance.get(asset, {}).get('free', 0)) if balance else 0
|
|
if qty > 0:
|
|
pair = f'{asset}USDT'
|
|
try:
|
|
price = await self.binance.get_ticker_price(pair)
|
|
if price and price > 0:
|
|
total_assets_usd += qty * price
|
|
except:
|
|
pass
|
|
except:
|
|
pass
|
|
|
|
real_win_rate = (self.wins_today / (self.wins_today + self.losses_today) * 100) if (self.wins_today + self.losses_today) > 0 else 0
|
|
avg_profit = (self.daily_pnl / (self.wins_today + self.losses_today)) if (self.wins_today + self.losses_today) > 0 else 0
|
|
daily_loss_pct = (self.daily_pnl / self.starting_capital) * 100 if self.starting_capital > 0 else 0
|
|
|
|
report = f'''📊 REPORT #{self.report_count}
|
|
|
|
💹 PORTFOLIO:
|
|
USDT: ${usdt:.2f} (CHF {usdt * 0.84:.2f})
|
|
Total Assets: ${total_assets_usd:.2f} (CHF {total_assets_usd * 0.84:.2f})
|
|
|
|
📈 TODAY'S PERFORMANCE:
|
|
Trades: {self.trades_today}
|
|
Wins: {self.wins_today} | Losses: {self.losses_today}
|
|
|
|
📊 REAL METRICS:
|
|
Win Rate: {real_win_rate:.1f}%
|
|
Avg P/L per Trade: ${avg_profit:+.2f} (CHF {avg_profit * 0.84:+.2f})
|
|
Daily P&L: ${self.daily_pnl:+.2f} (CHF {self.daily_pnl * 0.84:+.2f}) ({daily_loss_pct:+.1f}%)
|
|
Max Drawdown: ${self.max_drawdown:.2f} (CHF {self.max_drawdown * 0.84:.2f})
|
|
|
|
🤖 BOT STATUS: {'🟢 RUNNING' if time.time() >= self.error_cooldown_until else '🟡 ERROR_COOLDOWN'}
|
|
Open Positions: {len(self.open_positions)}
|
|
Error Count: {self.error_count}/{self.error_threshold}'''
|
|
|
|
logger.info(report)
|
|
await self.telegram.send_alert(report)
|
|
|
|
# Send all metrics to dashboard
|
|
balance = await self.binance.get_balance()
|
|
usdt = float(balance.get('USDT', {}).get('free', 0)) if balance else 0
|
|
|
|
total_assets_usd = usdt
|
|
for asset in ['BTC', 'ETH', 'SOL', 'BNB', 'XRP']:
|
|
try:
|
|
qty = float(balance.get(asset, {}).get('free', 0)) if balance else 0
|
|
if qty > 0:
|
|
pair = f'{asset}USDT'
|
|
price = await self.binance.get_ticker_price(pair)
|
|
if price and price > 0:
|
|
total_assets_usd += qty * price
|
|
except:
|
|
pass
|
|
|
|
await self.dashboard.update_state(
|
|
balance={'USDT': usdt},
|
|
daily_pnl=self.daily_pnl,
|
|
total_pnl=self.total_pnl,
|
|
trades_today=self.trades_today,
|
|
wins_today=self.wins_today,
|
|
losses_today=self.losses_today,
|
|
portfolio_value_usd=total_assets_usd
|
|
)
|
|
|
|
except Exception as e:
|
|
logger.error(f'Report error: {e}')
|
|
|
|
async def cancel_all_open_orders(self):
|
|
"""Cancel ALL open orders to free up locked capital"""
|
|
try:
|
|
logger.info('🗑️ CANCELLING ALL OPEN ORDERS...')
|
|
|
|
# Get all open orders
|
|
open_orders = await self.binance._get('openOrders')
|
|
|
|
if not open_orders:
|
|
logger.info('✅ No open orders to cancel')
|
|
return True
|
|
|
|
logger.warning(f'⚠️ Found {len(open_orders)} open orders!')
|
|
|
|
cancelled_count = 0
|
|
for order in open_orders:
|
|
try:
|
|
symbol = order.get('symbol')
|
|
order_id = order.get('orderId')
|
|
side = order.get('side')
|
|
qty = order.get('origQty')
|
|
|
|
logger.warning(f' Cancelling: {symbol} {side} {qty} (Order {order_id})')
|
|
|
|
result = await self.binance._delete(
|
|
'order',
|
|
True,
|
|
symbol=symbol,
|
|
orderId=order_id
|
|
)
|
|
|
|
cancelled_count += 1
|
|
logger.info(f' ✅ Cancelled: {symbol} {order_id}')
|
|
|
|
except Exception as e:
|
|
logger.error(f' ❌ Failed to cancel {symbol} {order_id}: {e}')
|
|
continue
|
|
|
|
logger.info(f'✅ CANCELLATION COMPLETE: {cancelled_count}/{len(open_orders)} orders cancelled')
|
|
return True
|
|
|
|
except Exception as e:
|
|
logger.error(f'❌ Failed to cancel orders: {e}')
|
|
return False
|
|
|
|
async def run(self):
|
|
"""Main bot loop"""
|
|
logger.info('🤖 BOT STARTED (V5 - SUSTAINABLE)')
|
|
|
|
# Create trigger file location
|
|
trigger_file = '/tmp/bot_liquidate_trigger'
|
|
|
|
# FIRST: Cancel all pending orders to free capital
|
|
await self.cancel_all_open_orders()
|
|
|
|
# SECOND: Load exchange info BEFORE liquidation
|
|
await self.load_exchange_info()
|
|
|
|
# THIRD: ONE-TIME LIQUIDATE BTC TO USDT IF NEEDED
|
|
await self.liquidate_btc_to_usdt_on_startup()
|
|
logger.info('🗑️ RESET: Clearing dashboard cache...')
|
|
try:
|
|
await self.dashboard.clear_state()
|
|
except:
|
|
pass
|
|
|
|
await self.telegram.send_alert(
|
|
'🤖 BOT V5 SUSTAINABLE STARTED\n'
|
|
'✅ All Bugs Fixed:\n'
|
|
' • Price fetching robust\n'
|
|
' • SWAP errors handled\n'
|
|
' • BUY orders executing\n'
|
|
' • EXIT orders scheduled\n'
|
|
' • Error resilience active'
|
|
)
|
|
|
|
while True:
|
|
try:
|
|
# CHECK FOR LIQUIDATION TRIGGER FILE (every cycle)
|
|
trigger_file = '/tmp/bot_liquidate_trigger'
|
|
trigger_exists = os.path.exists(trigger_file)
|
|
logger.info(f'🔍 Checking trigger file: exists={trigger_exists}') # DEBUG
|
|
|
|
if trigger_exists:
|
|
logger.warning(f'🔥🔥🔥 LIQUIDATION TRIGGER DETECTED! File exists at: {trigger_file}')
|
|
try:
|
|
os.remove(trigger_file)
|
|
logger.warning(f'🔥 Removed trigger file')
|
|
except Exception as e:
|
|
logger.error(f'Could not remove trigger: {e}')
|
|
result = await self.force_liquidate_all()
|
|
logger.warning(f'🔥 Force liquidation result: {result}')
|
|
await asyncio.sleep(2)
|
|
|
|
current_time = time.time()
|
|
|
|
# KONTINUIERLICH: Update dashboard mit aktueller Balance (every cycle!)
|
|
try:
|
|
balance = await self.binance.get_balance()
|
|
usdt_live = float(balance.get('USDT', {}).get('free', 0)) if balance else 0
|
|
|
|
# Calculate portfolio value with REAL prices from symbol_info
|
|
portfolio_value_usd = usdt_live # Start with USDT
|
|
|
|
for pair in self.pairs:
|
|
asset = pair.replace('USDT', '')
|
|
if asset in balance:
|
|
qty = float(balance[asset].get('free', 0))
|
|
if qty > 0 and pair in self.symbol_info:
|
|
# Use current price from symbol_info or last known
|
|
try:
|
|
current_price = await self.binance.get_ticker_price(pair)
|
|
if current_price and current_price > 0:
|
|
portfolio_value_usd += qty * current_price
|
|
except:
|
|
pass
|
|
|
|
logger.info(f'✅ Sending to dashboard: USDT={usdt_live:.2f}, portfolio={portfolio_value_usd:.2f}, trades_today={self.trades_today}, open_trades={len(self.open_positions)}')
|
|
|
|
# SYNC open_positions with dashboard
|
|
async with aiohttp.ClientSession() as session:
|
|
async with session.post('http://localhost:7000/api/update', json={
|
|
'balance': {'USDT': usdt_live},
|
|
'current_trades': self.open_positions, # Send ALL open positions!
|
|
'daily_pnl': self.daily_pnl,
|
|
'total_pnl': self.total_pnl,
|
|
'trades_today': self.trades_today,
|
|
'wins_today': self.wins_today,
|
|
'losses_today': self.losses_today,
|
|
'portfolio_value_usd': portfolio_value_usd,
|
|
'portfolio_value_chf': portfolio_value_usd * 0.84,
|
|
'last_update': datetime.now().isoformat()
|
|
}) as resp:
|
|
if resp.status == 200:
|
|
logger.debug('✅ Dashboard state synced')
|
|
else:
|
|
logger.warning(f'Dashboard sync failed: {resp.status}')
|
|
|
|
# Keep the old update_state call for compatibility
|
|
await self.dashboard.update_state(
|
|
balance={'USDT': usdt_live},
|
|
daily_pnl=self.daily_pnl,
|
|
portfolio_value_usd=portfolio_value_usd,
|
|
total_pnl=self.total_pnl,
|
|
trades_today=self.trades_today,
|
|
wins_today=self.wins_today,
|
|
losses_today=self.losses_today
|
|
)
|
|
except Exception as e:
|
|
logger.warning(f'⚠️ Dashboard update error: {e}')
|
|
|
|
now = datetime.now()
|
|
should_report = (now.hour in [22, 1, 4, 7, 10, 13, 16, 19]) and now.minute == 0
|
|
|
|
if should_report and (current_time - self.last_report_time) > 60:
|
|
await self.send_performance_report()
|
|
self.last_report_time = current_time
|
|
|
|
await self.monitor_trades()
|
|
await asyncio.sleep(10) # Check every 10 seconds for trigger and trading signals
|
|
|
|
except Exception as e:
|
|
logger.error(f'Main loop error: {e}')
|
|
await asyncio.sleep(60)
|
|
|
|
async def main():
|
|
logger.info('▶️ MAIN STARTUP')
|
|
try:
|
|
config = get_config()
|
|
logger.info(f'✅ Config loaded')
|
|
|
|
try:
|
|
dashboard = DashboardClient()
|
|
logger.info(f'✅ Dashboard client initialized')
|
|
except Exception as e:
|
|
logger.error(f'❌ Dashboard init failed: {e}')
|
|
dashboard = None
|
|
|
|
binance = BinanceClientWrapper(
|
|
api_key=config.binance_api_key_live,
|
|
api_secret=config.binance_api_secret_live,
|
|
testnet=False
|
|
)
|
|
logger.info(f'✅ Binance client initialized')
|
|
|
|
telegram = TelegramNotifier(bot_token=config.telegram_bot_token, chat_id=config.telegram_chat_id)
|
|
obsidian = ObsidianLogger(vault_path=config.obsidian_vault_path, trade_log_file=config.obsidian_trade_log_file)
|
|
|
|
model = joblib.load(config.model_path) if hasattr(config, 'model_path') else None
|
|
scaler = None
|
|
|
|
logger.info(f'✅ BOT CREATING...')
|
|
bot = MLTradingBot(config, binance, telegram, obsidian, model, scaler)
|
|
|
|
logger.info(f'✅ BOT CREATED. STARTING RUN()...')
|
|
await bot.run()
|
|
except Exception as e:
|
|
logger.critical(f'❌ FATAL ERROR IN MAIN: {e}', exc_info=True)
|
|
|
|
if __name__ == '__main__':
|
|
asyncio.run(main())
|
|
# Version marker: Auto-sync test Sat Jul 4 10:37:55 UTC 2026
|