Update autotrack.py

autotrack.py

@@ -1,497 +1,325 @@
-# autotrack.py — Unlimited milestones + auto-delete on drawdown + video ≥3×
+# autotrack.py
 import os
 import re
-import time
+import math
 import asyncio
-import aiohttp
-import sqlite3
 from dataclasses import dataclass, field
-from typing import Optional, Dict, Tuple
-from datetime import datetime, timezone, timedelta
+from datetime import datetime, timezone
+from typing import Dict, Optional, List
 
+import aiohttp
 from telethon import TelegramClient, events
-from telethon.sessions import StringSession, MemorySession
 
 # =========================
-# ENV / CONFIG
+# === CONFIG / ENV VARS ===
 # =========================
-API_ID = int(os.environ.get("API_ID", "0"))
-API_HASH = os.environ.get("API_HASH", "")
-STRING_SESSION = os.environ.get("STRING_SESSION", "")
-
-# Announce ke grup kamu (dipakai juga sebagai sumber pesan)
-TARGET_CHAT = os.environ.get("TARGET_CHAT", "https://t.me/MidasTouchsignalll")
-
-# Polling interval harga
-TRACK_POLL_SECS = int(os.environ.get("TRACK_POLL_SECS", "20"))
+API_ID          = int(os.getenv("TELEGRAM_API_ID", "0"))
+API_HASH        = os.getenv("TELEGRAM_API_HASH", "")
+SESSION         = os.getenv("TELEGRAM_SESSION", "autotrack.session")
 
-# Ambang reply awal (default 1.5×)
-REPLY_FROM_MULTIPLE = float(os.environ.get("REPLY_FROM_MULTIPLE", "1.5"))
+# Chat tempat botsignal mem-post (sumber) dan tempat reply milestone (biasanya sama)
+SOURCE_CHAT     = os.getenv("SOURCE_CHAT", "@MidasTouchsignalll")
+ANNOUNCE_CHAT   = os.getenv("ANNOUNCE_CHAT", SOURCE_CHAT)
 
-# Unlimited mode: selalu lanjut 2×, 3×, 4×, ...
-# Tidak berhenti otomatis
-STOP_WHEN_HIT = False
+# Milestones (float, dipisah koma) — default: 1.5×, 2×, 3×, 5×, 10×, 20×
+MILESTONES_ENV  = os.getenv("MILESTONES", "1.5,2,3,5,10,20")
+MILESTONES: List[float] = sorted({float(x.strip()) for x in MILESTONES_ENV.split(",") if x.strip()})
 
-# Abaikan pesan lebih tua dari (startup - buffer)
-BACKFILL_BUFFER_MINUTES = int(os.environ.get("BACKFILL_BUFFER_MINUTES", "3"))
+# Mulai arm di 1.5× dihitung dari ENTRY (bisa abaikan; milestone pertama biasanya >= 1.5)
+START_MULTIPLIER = float(os.getenv("START_MULTIPLIER", "1.5"))
 
-# Marker antirecursive: ditambahkan ke semua pengumuman bot (milestone)
-BOT_MARKER = "【MT-AUTOTRACK】"
+# Auto-delete saat turun X% dari entry. 0 = mati. Contoh 0.5 = hapus saat -50%
+DROP_DELETE_RATIO = float(os.getenv("DROP_DELETE_RATIO", "0"))
 
-# Lokasi DB milik botsignal (untuk ambil msg_id pesan awal)
-BOTSIGNAL_DB = os.environ.get("BOTSIGNAL_DB", "/tmp/botsignal.db")
+# Ref Axiom (opsional)
+AXIOM_REF = os.getenv("AXIOM_REF", "https://axiom.trade/@1144321")
 
-# NEW: Auto-delete bila drawdown >= threshold (rasio relatif terhadap entry)
-# Contoh: 0.5 berarti -50%. Set 0 untuk mematikan.
-DROP_DELETE_RATIO = float(os.environ.get("DROP_DELETE_RATIO", "0.5"))
+# Interval cek harga (detik)
+POLL_SEC = int(os.getenv("POLL_SEC", "30"))
 
-# (opsional) juga hapus thread balasan bot yang bertanda BOT_MARKER
-DELETE_THREAD_REPLIES = os.environ.get("DELETE_THREAD_REPLIES", "0") == "1"
+# Aktifkan preview tautan?
+LINK_PREVIEW = os.getenv("LINK_PREVIEW", "true").lower() not in {"0", "false", "no"}
 
-# >>> VIDEO milestone ≥ 3×
-# Nama file video di root repo (sefolder dengan autotrack.py). Ubah via env bila perlu.
-MILESTONE_VIDEO = os.environ.get("MILESTONE_VIDEO", "Generating_To_The_Moon_Animation.mp4")
-VIDEO_PATH = os.path.join(os.path.dirname(__file__), MILESTONE_VIDEO)
-VIDEO_MIN_MULTIPLE = float(os.environ.get("VIDEO_MIN_MULTIPLE", "3.0"))  # mulai kirim video dari x berapa
+BOT_MARKER = "【MT-AUTOTRACK】"
 
-# =========================
-# HTTP endpoints
-# =========================
-DEXSCREENER_TOKEN_URL = "https://api.dexscreener.com/latest/dex/tokens/"
-JUPITER_URL = "https://price.jup.ag/v6/price?ids="  # free (Solana only)
+# ===========================
+# === REGEX & PARSE UTILS ===
+# ===========================
+# EVM (0x...) & Solana (base58 32-44) + dukung pump.fun akhiran 'pump'
+CA_EVM_RE = re.compile(r"^0x[a-fA-F0-9]{40}$")
+CA_SOL_RE = re.compile(r"^[1-9A-HJ-NP-Za-km-z]{32,44}(?:pump)?$")
+
+# Cari CA di teks botsignal (baris 'CA: <addr>')
+CA_LINE_RE = re.compile(r"(?im)^\s*CA\s*:\s*`?([^\s`]+)`?\s*$")
+
+# Cari angka Market Cap di teks botsignal: "$213.97K → $325.34K" atau "$213.97K"
+MCAP_NUM_RE = re.compile(r"\$([\d.,]+)\s*([KMB])?", re.I)
+
+def _to_number(amt: str, suffix: Optional[str]) -> float:
+    """Convert $213.9K/$2.1M/$1.2B to float USD."""
+    x = float(amt.replace(",", ""))
+    mult = 1.0
+    if suffix:
+        s = suffix.upper()
+        if s == "K": mult = 1e3
+        elif s == "M": mult = 1e6
+        elif s == "B": mult = 1e9
+    return x * mult
+
+def _extract_first_mcap_usd(text: str) -> Optional[float]:
+    m = MCAP_NUM_RE.search(text)
+    if not m:
+        return None
+    return _to_number(m.group(1), m.group(2))
 
-# =========================
-# Helpers
-# =========================
-def _fmt_money(x: Optional[float]) -> str:
-    if x is None:
-        return "?"
-    if x >= 1:
-        return f"${x:,.4f}"
-    return f"${x:.8f}"
-
-def _fmt_big(x: Optional[float]) -> str:
-    if x is None:
-        return "?"
-    if x >= 1_000_000_000:
-        return f"${x/1_000_000_000:.2f}B"
-    if x >= 1_000_000:
-        return f"${x/1_000_000:.2f}M"
-    if x >= 1_000:
-        return f"${x/1_000:.2f}K"
-    return f"${x:.0f}"
-
-def _milestone_badge(m: float, basis: str) -> str:
+def _dexs_link_for_ca(ca: str) -> str:
+    """Universal Dexscreener link. Default ke Ethereum untuk EVM; Solana untuk base58; fallback /token."""
+    if CA_EVM_RE.fullmatch(ca):
+        return f"https://dexscreener.com/ethereum/{ca.lower()}"
+    if CA_SOL_RE.fullmatch(ca):
+        return f"https://dexscreener.com/solana/{ca}"
+    # Fallback — Dexscreener juga paham /token/<addr> untuk beberapa chain
+    return f"https://dexscreener.com/token/{ca}"
+
+def _fmt_usd(x: float) -> str:
+    if x >= 1e9:  return f"${x/1e9:.2f}B"
+    if x >= 1e6:  return f"${x/1e6:.2f}M"
+    if x >= 1e3:  return f"${x/1e3:.2f}K"
+    return f"${x:.2f}"
+
+def _ago_str(dt: datetime) -> str:
+    s = int((datetime.now(timezone.utc) - dt).total_seconds())
+    m, s = divmod(s, 60)
+    return f"{m}m {s}s"
+
+# ========================
+# === DEX API (async)  ===
+# ========================
+DEX_BASE = "https://api.dexscreener.com/latest/dex/tokens"
+
+async def fetch_mcap_usd(session: aiohttp.ClientSession, ca: str) -> Optional[float]:
     """
-    Balikin judul milestone yang menonjol untuk semua level.
-    basis: "mcap" atau "price"
+    Ambil marketCap dari Dexscreener. Jika tidak ada, fallback ke FDV.
+    Return USD float atau None.
     """
-    unit = "Market Cap" if basis == "mcap" else "Price"
-
-    # kategorisasi level agar konsisten & gampang dibaca
-    if m < 2.0 - 1e-9:              # 1.5× (reply awal)
-        return f"🟨 **ARMED — {m:.1f}× {unit}**"
-    elif abs(m - 2.0) < 1e-9:       # 2×
-        return f"🟩 **DOUBLE UP — 2× {unit}!**"
-    elif abs(m - 3.0) < 1e-9:       # 3×
-        return f"🔷 **TRIPLE — 3× {unit}!**"
-    elif 3.0 < m < 6.0:             # 4–5×
-        return f"🔶 **RALLY — {m:.0f}× {unit}!**"
-    elif 6.0 <= m < 10.0:           # 6–9×
-        return f"🟥 **OVERDRIVE — {m:.0f}× {unit}!**"
-    else:                           # 10×+
-        return f"🟣 **GOD CANDLE — {m:.0f}× {unit}!!**"
-
-# =========================
-# CA extraction
-# =========================
-CA_SOL_RE = re.compile(r"\b[1-9A-HJ-NP-Za-km-z]{32,48}\b")   # Solana base58 (approx)
-CA_EVM_RE = re.compile(r"\b0x[a-fA-F0-9]{40}\b")             # EVM 0x...
-
-CA_LABEL_RE = re.compile(r"\bCA\s*[:=]\s*(\S+)", re.IGNORECASE)
-
-def extract_ca(text: str) -> Optional[str]:
-    """Return first found CA (EVM or Solana). Prefer 'CA: <addr>' label if present."""
-    if not text:
+    url = f"{DEX_BASE}/{ca}"
+    try:
+        async with session.get(url, timeout=15) as resp:
+            if resp.status != 200:
+                return None
+            data = await resp.json()
+    except Exception:
         return None
-    m = CA_LABEL_RE.search(text)
-    if m:
-        cand = m.group(1)
-        if CA_EVM_RE.fullmatch(cand):
-            return cand.lower()
-        if CA_SOL_RE.fullmatch(cand):
-            return cand
-    m2 = CA_EVM_RE.search(text or "")
-    if m2:
-        return m2.group(0).lower()
-    m3 = CA_SOL_RE.search(text or "")
-    if m3:
-        return m3.group(0)
-    return None
-
-def ca_key_for_db(ca: str) -> Optional[str]:
-    if not ca:
+
+    pairs = data.get("pairs") or []
+    if not pairs:
         return None
-    if CA_EVM_RE.fullmatch(ca):
-        return f"ca:evm:{ca.lower()}"
-    if CA_SOL_RE.fullmatch(ca):
-        return f"ca:sol:{ca}"
-    return None
 
-def lookup_origin_msg_id(keyword: str) -> Optional[int]:
-    """Ambil msg_id pertama dari DB botsignal untuk keyword entitas CA."""
-    try:
-        conn = sqlite3.connect(BOTSIGNAL_DB)
-        cur = conn.cursor()
-        cur.execute("SELECT msg_id FROM last_posted WHERE keyword = ?", (keyword,))
-        row = cur.fetchone()
-        conn.close()
-        if row and isinstance(row[0], int):
-            return row[0]
+    # Ambil pair dengan liquidity/volume tertinggi (heuristik sederhana)
+    best = max(
+        pairs,
+        key=lambda p: (
+            (p.get("liquidity", {}) or {}).get("usd", 0)
+            + (p.get("volume", {}) or {}).get("h24", 0)
+        ),
+    )
+
+    mc = best.get("marketCap")
+    if mc is None:
+        mc = best.get("fdv")
+    if mc is None:
         return None
-    except Exception as e:
-        print(f"[TRACK][DB] lookup error: {e}")
+    try:
+        return float(mc)
+    except Exception:
         return None
 
 # =========================
-# Tracker core (UNLIMITED)
+# === TRACKING STRUCTS  ===
 # =========================
 @dataclass
 class TrackItem:
     ca: str
-    basis: str = "mcap"  # "mcap" (default) or "price"
-    entry_price: Optional[float] = None
-    entry_mcap: Optional[float] = None
-    symbol_hint: Optional[str] = None
-    source_link: Optional[str] = None
-    poll_secs: int = 20
-    next_milestone: float = field(default_factory=lambda: REPLY_FROM_MULTIPLE)
-    started_at: float = field(default_factory=time.time)
-
-class PriceTracker:
-    def __init__(self, client: TelegramClient, announce_chat):
-        self.client = client
-        self.announce_chat = announce_chat
-        self._tasks: Dict[str, asyncio.Task] = {}
-        self._items: Dict[str, TrackItem] = {}
-
-    # -------- HTTP helpers --------
-    async def _get(self, url: str, headers: Optional[Dict[str, str]] = None, timeout: int = 8):
-        tout = aiohttp.ClientTimeout(total=timeout)
-        async with aiohttp.ClientSession(timeout=tout, headers=headers) as sess:
-            async with sess.get(url) as r:
-                if r.status != 200:
-                    return None
-                return await r.json()
-
-    async def _dexscreener_price(self, ca: str) -> Optional[Tuple[Optional[float], Optional[str], Optional[float]]]:
-        data = await self._get(DEXSCREENER_TOKEN_URL + ca)
-        if not data:
-            return None
-        pairs = data.get("pairs") or []
-        if not pairs:
-            return None
-        best = max(pairs, key=lambda p: (p.get("liquidity", {}) or {}).get("usd", 0))
-        price = float(best.get("priceUsd")) if best.get("priceUsd") else None
-        symbol = ((best.get("baseToken") or {}).get("symbol")) or None
-
-        mcap = None
-        fdv = best.get("fdv")
-        if isinstance(fdv, (int, float)) and fdv > 0:
-            mcap = float(fdv)
-        mc = best.get("marketCap")
-        if isinstance(mc, (int, float)) and mc > 0:
-            mcap = float(mc)
-        return (price, symbol, mcap)
-
-    async def _jupiter_price(self, ca: str) -> Optional[float]:
-        try:
-            data = await self._get(JUPITER_URL + ca)
-            if not data:
-                return None
-            d = (data.get("data") or {}).get(ca)
-            if not d:
-                return None
-            p = d.get("price")
-            return float(p) if p is not None else None
-        except:
-            return None
-
-    async def _get_snapshot(self, ca: str) -> Optional[Dict[str, Optional[float]]]:
-        res = await self._dexscreener_price(ca)
-        if res:
-            price, sym, mcap = res
-            if price is None:
-                jp = await self._jupiter_price(ca)
-                price = jp if jp is not None else None
-            return {"price": price, "mcap": mcap, "symbol_hint": sym}
-        jp = await self._jupiter_price(ca)
-        if jp is not None:
-            return {"price": jp, "mcap": None, "symbol_hint": None}
-        return None
-
-    # -------- Announce helpers --------
-    def _name(self, item: TrackItem) -> str:
-        s = item.symbol_hint or ""
-        return f"{s} ({item.ca[:4]}…{item.ca[-4:]})" if s else item.ca
+    entry_mcap: float
+    started_at: datetime
+    source_msg_id: int                 # id pesan botsignal yg di-reply
+    posted: Dict[float, bool] = field(default_factory=dict)  # milestone -> posted?
+    last_announce_id: Optional[int] = None
+
+    def ready_milestones(self, current_mcap: float) -> List[float]:
+        """Milestone yang belum pernah dipost dan sudah terlewati."""
+        if not self.entry_mcap or self.entry_mcap <= 0:
+            return []
+        mult = current_mcap / self.entry_mcap
+        return [m for m in MILESTONES if mult >= m and not self.posted.get(m, False)]
+
+    def drop_hit(self, current_mcap: float) -> bool:
+        if DROP_DELETE_RATIO <= 0:
+            return False
+        return current_mcap <= self.entry_mcap * (1 - DROP_DELETE_RATIO)
 
-    async def _send_reply_to_origin(self, ca: str, text: str):
-        try:
-            key = ca_key_for_db(ca)
-            reply_to_id = lookup_origin_msg_id(key) if key else None
-            if reply_to_id:
-                await self.client.send_message(self.announce_chat, f"{text}\n\n{BOT_MARKER}", reply_to=reply_to_id, link_preview=False)
-            else:
-                await self.client.send_message(self.announce_chat, f"{text}\n\n{BOT_MARKER}", link_preview=False)
-        except Exception as e:
-            print(f"[TRACK] reply failed: {e}")
-
-    def _milestone_text(self, item: TrackItem, m: float, ratio: float,
-                        cur_price: Optional[float], cur_mcap: Optional[float]) -> str:
-        dexs_link = f"https://dexscreener.com/solana/{item.ca}"
-        axiom_link = "https://axiom.trade/@1144321"
-        if item.basis == "mcap":
-            change = f"{_fmt_big(item.entry_mcap)} → {_fmt_big(cur_mcap)}  (~{ratio:.2f}×)"
-        else:
-            change = f"{_fmt_money(item.entry_price)} → {_fmt_money(cur_price)}  (~{ratio:.2f}×)"
-        milestone_line = _milestone_badge(m, item.basis)
-        elapsed = int(time.time() - item.started_at)
-        mm, ss = divmod(elapsed, 60)
-        header = "💎 [MidasTouch Signal] 💎\n━━━━━━━━━━━━━━━━"
-        footer = "━━━━━━━━━━━━━━━━"
-        body = (
-            f"{header}\n"
-            f"{milestone_line}\n"
-            f"{self._name(item)}\n"
-            f"{change}\n"
-            f"⏱️ {mm}m {ss}s since call\n"
-            f"🔎 [Dexscreener]({dexs_link})\n"
-            f"🛒 [Trade on Axiom]({axiom_link})\n"
-            f"CA: `{item.ca}`\n"
-            f"{footer}"
-        )
-        return body
-
-    def _next_target_after(self, current_target: float) -> float:
-        # Setelah 1.5×, lanjut integer berikutnya: 2×, 3×, 4×, ...
-        return 2.0 if current_target < 2.0 else current_target + 1.0
-
-    async def _delete_origin_and_replies(self, ca: str):
-        """Hapus pesan origin di TARGET_CHAT (dan opsional balasan bot)."""
-        try:
-            key = ca_key_for_db(ca)
-            msg_id = lookup_origin_msg_id(key) if key else None
-            if not msg_id:
+# =========================
+# === CORE AUTOTRACKER  ===
+# =========================
+class AutoTracker:
+    def __init__(self, client: TelegramClient):
+        self.client = client
+        self.source_chat = SOURCE_CHAT
+        self.announce_chat = ANNOUNCE_CHAT
+        self.session = None  # aiohttp
+        self.by_ca: Dict[str, TrackItem] = {}         # CA -> TrackItem
+        self.ca_to_msg: Dict[str, int] = {}           # CA -> source message id (botsignal)
+
+    async def start(self):
+        self.session = aiohttp.ClientSession()
+        # Listener: tangkap pesan botsignal yang mengandung CA dan entry mcap
+        @self.client.on(events.NewMessage(chats=self.source_chat))
+        async def handler(ev):
+            text = (ev.raw_text or "").strip()
+
+            # Cari CA
+            ca = None
+            m = CA_LINE_RE.search(text)
+            if m:
+                ca = m.group(1).strip()
+
+            if not ca:
                 return
-            # Hapus pesan origin
-            await self.client.delete_messages(self.announce_chat, msg_id)
-            print(f"[TRACK] Deleted origin message for {ca}")
-
-            if DELETE_THREAD_REPLIES:
-                # Coba ambil beberapa pesan terakhir & hapus balasan bot yang menandai BOT_MARKER dan reply_to origin
-                try:
-                    async for m in self.client.iter_messages(self.announce_chat, limit=100, reply_to=msg_id):
-                        txt = (m.message or "") if hasattr(m, "message") else ""
-                        if BOT_MARKER in (txt or ""):
-                            await self.client.delete_messages(self.announce_chat, m.id)
-                    print(f"[TRACK] Deleted thread replies for {ca}")
-                except Exception as e:
-                    print(f"[TRACK] delete thread replies failed: {e}")
-        except Exception as e:
-            print(f"[TRACK] delete origin failed: {e}")
-
-    # -------- Loop --------
-    async def _loop(self, item: TrackItem):
-        snap = await self._get_snapshot(item.ca)
-        if not snap:
-            print(f"[TRACK] init snapshot failed for {item.ca}")
-            return
 
-        if item.entry_price is None:
-            item.entry_price = snap.get("price")
-        if item.entry_mcap is None:
-            item.entry_mcap = snap.get("mcap")
-        if not item.symbol_hint and snap.get("symbol_hint"):
-            item.symbol_hint = snap.get("symbol_hint")
+            # Normalisasi some pump.fun-style? biarkan apa adanya — Dexscreener menerima addr itu.
+            entry_mcap = _extract_first_mcap_usd(text)  # ambil angka MCAP pertama yg muncul
 
-        if item.basis == "mcap" and not item.entry_mcap:
-            item.basis = "price"
+            # Kalau tidak ada mcap di pesan, jangan arm dulu — tunggu pesan update lain
+            if not entry_mcap:
+                return
 
+            # Simpan mapping CA -> source message id
+            self.ca_to_msg[ca] = ev.message.id
+
+            # Arm jika belum ada
+            if ca not in self.by_ca:
+                self.by_ca[ca] = TrackItem(
+                    ca=ca,
+                    entry_mcap=entry_mcap,
+                    started_at=datetime.now(timezone.utc),
+                    source_msg_id=ev.message.id,
+                )
+                # Optional: kasih jejak kecil di log (tidak kirim ke chat)
+                print(f"[ARMED] {ca} at {entry_mcap:.2f} USD (msg {ev.message.id})")
+
+        # Loop polling harga
+        asyncio.create_task(self._poll_loop())
+
+    async def _poll_loop(self):
+        await self.client.connect()
         while True:
-            snap = await self._get_snapshot(item.ca)
-            if not snap:
-                await asyncio.sleep(item.poll_secs)
-                continue
-
-            cur_price = snap.get("price")
-            cur_mcap = snap.get("mcap")
-            if not item.symbol_hint and snap.get("symbol_hint"):
-                item.symbol_hint = snap.get("symbol_hint")
-
-            # Hitung rasio vs entry
-            if item.basis == "mcap":
-                if not (item.entry_mcap and cur_mcap):
-                    await asyncio.sleep(item.poll_secs)
+            try:
+                await self._tick()
+            except Exception as e:
+                print("[POLL_ERR]", e)
+            await asyncio.sleep(POLL_SEC)
+
+    async def _tick(self):
+        if not self.by_ca:
+            return
+        async with aiohttp.ClientSession() as sess:
+            for ca, item in list(self.by_ca.items()):
+                current = await fetch_mcap_usd(sess, ca)
+                if not current:
                     continue
-                ratio = (cur_mcap / item.entry_mcap) if item.entry_mcap > 0 else 0.0
-            else:
-                if not (item.entry_price and cur_price):
-                    await asyncio.sleep(item.poll_secs)
+
+                # Auto-delete bila drop
+                if item.drop_hit(current):
+                    await self._handle_drop_delete(item, current)
+                    # Setelah hapus, hentikan tracking CA ini
+                    self.by_ca.pop(ca, None)
                     continue
-                ratio = (cur_price / item.entry_price) if item.entry_price > 0 else 0.0
-
-            # === NEW: auto delete kalau drop >= threshold ===
-            # ratio <= 0.5 berarti -50% dari entry (default)
-            if DROP_DELETE_RATIO > 0 and ratio <= DROP_DELETE_RATIO:
-                await self._delete_origin_and_replies(item.ca)
-                return  # stop tracking setelah dihapus
-
-            # --- milestone handling ---
-            while ratio >= item.next_milestone:
-                text = self._milestone_text(item, item.next_milestone, ratio, cur_price, cur_mcap)
-                key = ca_key_for_db(item.ca)
-                reply_to_id = lookup_origin_msg_id(key) if key else None
-                # Gabungkan jadi 1 pesan: kalau ≥ VIDEO_MIN_MULTIPLE dan ada file → kirim video dengan caption = text
-                if item.next_milestone >= VIDEO_MIN_MULTIPLE and os.path.isfile(VIDEO_PATH):
-                    try:
-                        await self.client.send_file(
-                            self.announce_chat,
-                            VIDEO_PATH,
-                            caption=f"{text}\n\n{BOT_MARKER}",
-                            reply_to=reply_to_id if reply_to_id else None,
-                            force_document=False
-                        )
-                    except Exception as e:
-                        print(f"[TRACK] gagal kirim video: {e}")
-                else:
-                    await self.client.send_message(
-                        self.announce_chat,
-                        f"{text}\n\n{BOT_MARKER}",
-                        reply_to=reply_to_id if reply_to_id else None,
-                        link_preview=False
-                    )
-                # Naikkan target ke milestone berikut
-                item.next_milestone = self._next_target_after(item.next_milestone)
-
-            await asyncio.sleep(item.poll_secs)
-
-    # -------- Public --------
-    def is_tracking(self, ca: str) -> bool:
-        t = self._tasks.get(ca)
-        return bool(t) and not t.done()
-
-    async def start(self, ca: str, *, basis: str = "mcap",
-                    entry_price: Optional[float] = None,
-                    entry_mcap: Optional[float] = None,
-                    poll_secs: int = 20,
-                    source_link: Optional[str] = None,
-                    symbol_hint: Optional[str] = None):
-        ca = ca.strip()
-        if self.is_tracking(ca):
-            return
-        item = TrackItem(
-            ca=ca,
-            basis=basis.lower(),
-            entry_price=entry_price,
-            entry_mcap=entry_mcap,
-            poll_secs=poll_secs,
-            source_link=source_link,
-            symbol_hint=symbol_hint,
-            next_milestone=REPLY_FROM_MULTIPLE,
-        )
-        self._tasks[ca] = asyncio.create_task(self._loop(item))
 
+                # Milestones tercapai?
+                ready = item.ready_milestones(current)
+                if not ready:
+                    continue
 
-# =========================
-# Setup: attach to existing client from botsignal
-# =========================
-def setup_autotrack(shared_client: TelegramClient, announce_chat: str | None = None):
-    global client, tracker, startup_time_utc
-    client = shared_client
-    ac = announce_chat or TARGET_CHAT
-    tracker = PriceTracker(client, announce_chat=ac)
-    startup_time_utc = datetime.now(timezone.utc)
-    client.add_event_handler(on_new_message, events.NewMessage(chats=(TARGET_CHAT,)))
-    print("[AUTOTRACK] attached to shared client; listening on", TARGET_CHAT)
+                # Post untuk setiap milestone yang terlewati (urut kecil -> besar)
+                ready.sort()
+                for m in ready:
+                    await self._post_milestone(item, m, current)
+                    item.posted[m] = True
 
-# =========================
-# Client bootstrap
-# =========================
-def build_client() -> TelegramClient:
-    if STRING_SESSION:
-        print(">> Using StringSession (persistent).")
-        return TelegramClient(StringSession(STRING_SESSION), API_ID, API_HASH)
-    print(">> Using MemorySession (login each run).")
-    return TelegramClient(MemorySession(), API_ID, API_HASH)
-
-client: TelegramClient | None = None
-startup_time_utc = None
-me_user_id: Optional[int] = None
-tracker: PriceTracker | None = None
+    async def _handle_drop_delete(self, item: TrackItem, current_mcap: float):
+        """Opsional hapus thread ketika drawdown tembus ambang."""
+        try:
+            # Hapus pesan milestone terakhir (jika ada)
+            if item.last_announce_id:
+                await self.client.delete_messages(self.announce_chat, item.last_announce_id)
+            # Hapus pesan sumber botsignal
+            await self.client.delete_messages(self.source_chat, item.source_msg_id)
+            print(f"[DROP-DELETE] {item.ca} @ {_fmt_usd(current_mcap)} (entry {_fmt_usd(item.entry_mcap)})")
+        except Exception as e:
+            print("[DROP-DELETE ERR]", e)
+
+    def _milestone_text(self, item: TrackItem, milestone: float, current_mcap: float) -> str:
+        dexs_link = _dexs_link_for_ca(item.ca)
+        badge = self._badge_for(milestone)
+        change_line = f"{_fmt_usd(item.entry_mcap)} → {_fmt_usd(current_mcap)}  (~{current_mcap/item.entry_mcap:.2f}×)"
+        axiom_line = f"🛒 [Trade on Axiom]({AXIOM_REF})" if AXIOM_REF else ""
+        elapsed = _ago_str(item.started_at)
+
+        lines = [
+            "💎 [MidasTouch Signal] 💎",
+            f"{badge}",
+            f"{change_line}",
+            f"⏱️ {elapsed} since call",
+            f"🔎 [Dexscreener]({dexs_link})",
+        ]
+        if axiom_line:
+            lines.append(axiom_line)
+        lines.append(f"CA: `{item.ca}`")
+
+        return "\n".join(lines)
+
+    def _badge_for(self, m: float) -> str:
+        if m >= 10:
+            return f"🚀 **Spectacular Milestone {m:g}×**"
+        if m >= 5:
+            return f"🚀 **Milestone {m:g}×**"
+        if m >= 3:
+            return f"🔥 Milestone {m:g}×"
+        if m >= 2:
+            return f"⚡ Milestone {m:g}×"
+        return f"🎯 Milestone {m:g}×"
+
+    async def _post_milestone(self, item: TrackItem, milestone: float, current_mcap: float):
+        text = self._milestone_text(item, milestone, current_mcap)
+        try:
+            msg = await self.client.send_message(
+                self.announce_chat,
+                f"{text}\n\n{BOT_MARKER}",
+                reply_to=item.source_msg_id,
+                link_preview=LINK_PREVIEW,   # Penting: preview ON agar link Dexs klik-able & terlihat
+            )
+            item.last_announce_id = msg.id
+            print(f"[MILESTONE] {item.ca} hit {milestone}× → posted (msg {msg.id})")
+        except Exception as e:
+            print("[POST_ERR]", e)
 
 # =========================
-# Event handler: ONLY your group
+# === BOOTSTRAP / MAIN  ===
 # =========================
-CUTOFF_BUFFER = timedelta(minutes=BACKFILL_BUFFER_MINUTES)
+def main():
+    if not API_ID or not API_HASH:
+        raise SystemExit("Set TELEGRAM_API_ID/TELEGRAM_API_HASH environment variables first.")
 
-def _is_old_message(msg_dt: Optional[datetime]) -> bool:
-    if not isinstance(msg_dt, datetime):
-        return False
-    return msg_dt.replace(tzinfo=timezone.utc) < (startup_time_utc - CUTOFF_BUFFER)
+    client = TelegramClient(SESSION, API_ID, API_HASH)
+    tracker = AutoTracker(client)
 
-def _is_bot_own_message(event) -> bool:
-    txt = (event.raw_text or "") if hasattr(event, "raw_text") else ""
-    return BOT_MARKER in (txt or "")
+    async def runner():
+        await tracker.start()
+        print("[BOOT] autotrack attached ✓")
+        await client.run_until_disconnected()
 
-async def on_new_message(event):
-    try:
-        if _is_bot_own_message(event):
-            return
-        msg = event.message
-        if _is_old_message(getattr(msg, "date", None)):
-            return
-        text = msg.message or (getattr(msg, "raw_text", None) or "")
-        ca = extract_ca(text)
-        if not ca:
-            return
-        # Optional: link back to source (tidak dipakai di teks sekarang, tapi disimpan kalau perlu)
-        source_link = None
-        try:
-            chat = await event.get_chat()
-            uname = getattr(chat, "username", None)
-            mid = getattr(msg, "id", None)
-            if uname and mid:
-                source_link = f"https://t.me/{uname}/{mid}"
-        except:
-            pass
-        await tracker.start(
-            ca=ca,
-            basis="mcap",
-            poll_secs=TRACK_POLL_SECS,
-            source_link=source_link,
-        )
-    except Exception as e:
-        print(f"[AUTOTRACK] error: {e}")
-
-# =========================
-# Entrypoint
-# =========================
-async def main():
-    global client, tracker, startup_time_utc
-    if client is None:
-        client = build_client()
-    startup_time_utc = datetime.now(timezone.utc)
-    tracker = PriceTracker(client, announce_chat=TARGET_CHAT)
-    await client.start()
-    try:
-        me = await client.get_me()
-        globals()["me_user_id"] = int(getattr(me, "id", 0))
-        print(f">> Logged in as: {getattr(me, 'username', None) or me_user_id}")
-    except Exception as e:
-        print(f"Warning: cannot resolve self id: {e}")
-    print(f"AutoTrack running (unlimited milestones; first reply ≥ {REPLY_FROM_MULTIPLE}×). Listening ONLY your group for NEW messages...")
-    client.add_event_handler(on_new_message, events.NewMessage(chats=(TARGET_CHAT,)))
-    await client.run_until_disconnected()
+    with client:
+        client.loop.run_until_complete(runner())
 
 if __name__ == "__main__":
-    asyncio.run(main())
+    main()