done

app/services/recovery.py

@@ -0,0 +1,89 @@
+"""
+Startup rehydration: re-register TP/SL + max-hold for every open trade in DB.
+
+Called once from lifespan() after tables are ensured. Without this, any deploy
+or crash silently drops TP/SL protection on live positions.
+"""
+import asyncio
+import logging
+from datetime import datetime, timezone
+
+from sqlalchemy import select
+
+from app.database import AsyncSessionLocal
+from app.models import BotTrade, Subscription
+
+logger = logging.getLogger(__name__)
+
+
+async def rehydrate_open_trades() -> None:
+    # Imported locally to avoid circular imports at module load
+    from app.services.bot_engine import MAX_HOLD_SECONDS, _close_after_hold, close_and_finalize
+    from app.services.crypto import decrypt_api_key
+    from app.services.tp_sl_monitor import register_trade
+
+    async with AsyncSessionLocal() as db:
+        result = await db.execute(select(BotTrade).where(BotTrade.closed_at.is_(None)))
+        open_trades = result.scalars().all()
+
+        if not open_trades:
+            logger.info("Rehydration: no open trades.")
+            return
+
+        now = datetime.now(timezone.utc)
+        for t in open_trades:
+            sub_res = await db.execute(
+                select(Subscription).where(Subscription.wallet_address == t.wallet_address)
+            )
+            sub = sub_res.scalar_one_or_none()
+            if sub is None or not sub.hl_api_key:
+                logger.warning(
+                    "Open trade %d has no subscription/key — marking as closed(abandoned)", t.id
+                )
+                t.closed_at = now.replace(tzinfo=None)
+                continue
+
+            try:
+                api_key = decrypt_api_key(sub.hl_api_key)
+            except Exception as exc:
+                logger.error("Cannot decrypt key for trade %d: %s", t.id, exc)
+                continue
+
+            # Re-register TP/SL watcher
+            register_trade(
+                trade_id=t.id,
+                wallet=t.wallet_address,
+                api_key=api_key,
+                leverage=sub.leverage,
+                asset=t.asset,
+                side=t.side,
+                entry_price=t.entry_price,
+                take_profit_pct=sub.take_profit_pct,
+                stop_loss_pct=sub.stop_loss_pct,
+            )
+
+            # Compute remaining hold; if already exceeded, close immediately
+            opened_aware = t.opened_at.replace(tzinfo=timezone.utc)
+            elapsed = (now - opened_aware).total_seconds()
+            remaining = MAX_HOLD_SECONDS - elapsed
+
+            if remaining <= 0:
+                logger.info("Trade %d past max-hold on startup — closing now", t.id)
+                asyncio.create_task(
+                    close_and_finalize(
+                        trade_id=t.id, api_key=api_key, leverage=sub.leverage,
+                        asset=t.asset, wallet=t.wallet_address, reason="max_hold_recovery",
+                    )
+                )
+            else:
+                async def _delayed_close(trade_id=t.id, key=api_key, lev=sub.leverage,
+                                         asset=t.asset, wallet=t.wallet_address, delay=remaining):
+                    await asyncio.sleep(delay)
+                    await close_and_finalize(
+                        trade_id=trade_id, api_key=key, leverage=lev,
+                        asset=asset, wallet=wallet, reason="max_hold",
+                    )
+                asyncio.create_task(_delayed_close())
+
+        await db.commit()
+        logger.info("Rehydrated %d open trades.", len(open_trades))