Update autotrack.py

autotrack.py

@@ -1,3 +1,4 @@
+# autotrack.py — Unlimited milestones + auto-delete on drawdown + video ≥3×
 import os
 import re
 import time
@@ -5,10 +6,11 @@ import asyncio
 import aiohttp
 import sqlite3
 from dataclasses import dataclass, field
-from typing import Optional, Dict, Tuple, List, Sequence
+from typing import Optional, Dict, Tuple
+from datetime import datetime, timezone, timedelta
 
 from telethon import TelegramClient, events
-from telethon.sessions import StringSession
+from telethon.sessions import StringSession, MemorySession
 
 # =========================
 # ENV / CONFIG
@@ -27,75 +29,139 @@ TRACK_POLL_SECS = int(os.environ.get("TRACK_POLL_SECS", "20"))
 REPLY_FROM_MULTIPLE = float(os.environ.get("REPLY_FROM_MULTIPLE", "1.5"))
 
 # Unlimited mode: selalu lanjut 2×, 3×, 4×, ...
-UNLIMITED_MODE = True
+# Tidak berhenti otomatis
+STOP_WHEN_HIT = False
 
-# Optional: kirim video mulai dari rasio ini
-VIDEO_MIN_MULTIPLE = float(os.environ.get("VIDEO_MIN_MULTIPLE", "3"))
+# Abaikan pesan lebih tua dari (startup - buffer)
+BACKFILL_BUFFER_MINUTES = int(os.environ.get("BACKFILL_BUFFER_MINUTES", "3"))
+CUTOFF_BUFFER = timedelta(minutes=BACKFILL_BUFFER_MINUTES)
 
-# Marker khusus biar gampang difilter
+# NEW: matikan cutoff default (biar pesan yang dipost sedikit sebelum attach tetap diproses).
+DISABLE_OLD_MESSAGE_CUTOFF = os.environ.get("DISABLE_OLD_MESSAGE_CUTOFF", "1") == "1"
+
+# Marker antirecursive: ditambahkan ke semua pengumuman bot (milestone)
 BOT_MARKER = "【MT-AUTOTRACK】"
 
-# Dexscreener endpoint (Solana; ganti jika chain lain)
-DEXSCREENER_TOKEN_URL = "https://api.dexscreener.com/latest/dex/tokens/"
+# Lokasi DB milik botsignal (untuk ambil msg_id pesan awal)
+BOTSIGNAL_DB = os.environ.get("BOTSIGNAL_DB", "/tmp/botsignal.db")
+
+# 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"))
+
+# (opsional) juga hapus thread balasan bot yang bertanda BOT_MARKER
+DELETE_THREAD_REPLIES = os.environ.get("DELETE_THREAD_REPLIES", "0") == "1"
 
-# Axiom referal (CTA)
-AXIOM_REF = os.environ.get("AXIOM_REF", "https://axiom.trade/@1144321")
+# >>> 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
 
 # =========================
-# DB (opsional, untuk menyimpan origin message id)
+# HTTP endpoints
 # =========================
-DB_PATH = os.environ.get("AUTOTRACK_DB", "/tmp/autotrack.db")
+DEXSCREENER_TOKEN_URL = "https://api.dexscreener.com/latest/dex/tokens/"
+JUPITER_URL = "https://price.jup.ag/v6/price?ids="  # free (Solana only)
 
-def _db():
-    conn = sqlite3.connect(DB_PATH)
-    conn.execute(
-        "CREATE TABLE IF NOT EXISTS origin (ca TEXT PRIMARY KEY, origin_msg_id INTEGER)"
-    )
-    return conn
+# =========================
+# 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 _parse_target_username(url_or_username: str) -> Optional[str]:
+    """Terima 'https://t.me/xxx' atau '@xxx' atau 'xxx' → kembalikan 'xxx' (lower)."""
+    if not url_or_username:
+        return None
+    s = url_or_username.strip()
+    if s.startswith("https://t.me/"):
+        s = s.split("https://t.me/", 1)[1]
+    if s.startswith("@"):
+        s = s[1:]
+    return s.lower()
 
-def save_origin_msg_id(ca_key: str, msg_id: int):
-    try:
-        with _db() as c:
-            c.execute(
-                "INSERT OR REPLACE INTO origin (ca, origin_msg_id) VALUES (?,?)",
-                (ca_key, msg_id),
-            )
-    except Exception as e:
-        print(f"[DB] save_origin_msg_id failed: {e}")
+# =========================
+# 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 lookup_origin_msg_id(ca_key: str) -> Optional[int]:
+def extract_ca(text: str) -> Optional[str]:
+    """Return first found CA (EVM or Solana). Prefer 'CA: <addr>' label if present."""
+    if not text:
+        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:
+        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:
-        with _db() as c:
-            cur = c.execute("SELECT origin_msg_id FROM origin WHERE ca=?", (ca_key,))
-            row = cur.fetchone()
-            return int(row[0]) if row and row[0] is not None else None
+        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]
+        return None
     except Exception as e:
-        print(f"[DB] lookup_origin_msg_id failed: {e}")
+        print(f"[TRACK][DB] lookup error: {e}")
         return None
 
-def ca_key_for_db(ca: str) -> str:
-    return ca.lower().strip()
-
 # =========================
-# Dataclass item track
+# Tracker core (UNLIMITED)
 # =========================
 @dataclass
 class TrackItem:
     ca: str
-    symbol_hint: Optional[str] = None   # jika kamu parsing symbol dari pesan
-    basis: str = "mcap"                 # "mcap" atau "price"
-    entry_mcap: Optional[float] = None
+    basis: str = "mcap"  # "mcap" (default) or "price"
     entry_price: Optional[float] = None
-    origin_msg_id: Optional[int] = None
-    started_at: int = field(default_factory=lambda: int(time.time()))
-    # milestone yang sudah tercapai
-    milestones_hit: List[float] = field(default_factory=list)
-    # untuk opsi cleanup/edit (tidak dipakai default)
-    last_reply_msg_id: Optional[int] = 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)
 
-# =========================
-# PriceTracker
-# =========================
 class PriceTracker:
     def __init__(self, client: TelegramClient, announce_chat):
         self.client = client
@@ -119,356 +185,344 @@ class PriceTracker:
         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
 
-        # ambil pair terbaik (likuiditas/vol atau rank Dexscreener)
-        # fallback sederhana: ambil yang punya mcap
-        best = max(pairs, key=lambda p: float(p.get("fdv", 0) or 0.0))
-        price_str = best.get("priceUsd")
-        price = float(price_str) if price_str else None
-        mcap = float(best.get("fdv")) if best.get("fdv") is not None else None
-        symbol = best.get("baseToken", {}).get("symbol")
-        return price, symbol, mcap
-
-    # -------- Format helpers (tetap sederhana & aman Markdown) --------
-    def _fmt_money(self, v: Optional[float]) -> str:
-        if v is None:
-            return "-"
-        if v >= 1:
-            return f"${v:,.2f}"
-        return f"${v:.8f}".rstrip("0").rstrip(".")
-
-    def _fmt_big(self, v: Optional[float]) -> str:
-        if v is None:
-            return "-"
-        if v >= 1_000_000_000:
-            return f"${v/1_000_000_000:.2f}B"
-        if v >= 1_000_000:
-            return f"${v/1_000_000:.2f}M"
-        if v >= 1_000:
-            return f"${v/1_000:.2f}K"
-        return f"${v:.2f}"
+    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
 
-    # ======= (Tambahan untuk MEMPERCANTIK output — tidak mengubah flow) =======
-    def _progress_bar(self, ratio_hit: float, milestone: float, width: int = 12) -> str:
-        """Render progress 0..milestone (▮/▯)."""
-        try:
-            pct = max(0.0, min(1.0, (ratio_hit / max(milestone, 1e-9))))
-        except Exception:
-            pct = 0.0
-        filled = int(round(pct * width))
-        return "▮" * filled + "▯" * (width - filled)
-
-    def _headline_and_spice(self, m: float) -> tuple[str, str]:
-        """Headline & bumbu copywriting berdasar milestone."""
-        if m < 2:
-            return ("✨ **MidasTouch Milestone**", "Momentum ignited.")
-        elif m < 3:
-            return ("⚡ **MidasTouch Breakout**", "Pressure building—eyes on next leg.")
-        elif m < 5:
-            return ("🚀 **MidasTouch Liftoff**", "To the moon vibes.")
-        else:
-            return ("🌕 **MidasTouch Moon Mission**", "Price discovery—no ceilings.")
-
-    def _badge(self, ratio: float) -> str:
-        """Lencana rasa (ringan) berdasar rasio."""
-        if ratio >= 8:
-            return "FOMO 🔥"
-        elif ratio >= 5:
-            return "Strong 💪"
-        elif ratio >= 3:
-            return "Medium ⚡"
-        else:
-            return "Low 🌱"
-
-    # -------- Kirim reply ke origin msg --------
-    async def _send_reply_to_origin(self, ca: str, text: str, file_list: Optional[List[str]] = None):
+    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, file=file_list or None
-                )
+                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, file=file_list or None
-                )
+                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}")
 
-    # -------- Text milestone (DIPERCANTIK tanpa ubah flow lain) --------
     def _milestone_text(self, item: TrackItem, m: float, ratio: float,
-                        cur_price: Optional[float], cur_mcap: Optional[float]) -> str:
-        # Links (Solana style)
+                    cur_price: Optional[float], cur_mcap: Optional[float]) -> str:
+    # Links & label basis
         dexs_link = f"https://dexscreener.com/solana/{item.ca}"
-        axiom_link = AXIOM_REF
+        axiom_link = "https://axiom.trade/@1144321"
+        basis_label = "Market Cap" if item.basis == "mcap" else "Price"
 
-        # Headline & badge
-        headline, spice = self._headline_and_spice(m)
-        badge = self._badge(ratio)
-
-        # Perubahan nilai
+        # Perubahan angka (jaga format sesuai basis)
         if item.basis == "mcap":
-            change = f"{self._fmt_big(item.entry_mcap)} → {self._fmt_big(cur_mcap)}  (~{ratio:.2f}×)"
-            basis_line = f"**{m}× Market Cap** ✅"
+            change = f"{_fmt_big(item.entry_mcap)} → {_fmt_big(cur_mcap)} (~{ratio:.2f}×)"
         else:
-            change = f"{self._fmt_money(item.entry_price)} → {self._fmt_money(cur_price)}  (~{ratio:.2f}×)"
-            basis_line = f"**{m}× Price** ✅"
+            change = f"{_fmt_money(item.entry_price)} → {_fmt_money(cur_price)} (~{ratio:.2f}×)"
 
-        # Nama token
-        name_line = f"**{self._name(item)}**"
+        # Nama token (punya fallback yg sudah ada)
+        name = self._name(item)
 
-        # Waktu sejak call
+        # Elapsed time (hh:mm:ss)
         elapsed = int(time.time() - item.started_at)
-        mm, ss = divmod(elapsed, 60)
-        t_since = f"{mm}m {ss:02d}s since call"
-
-        # Progress bar pada skala milestone yang baru tercapai
-        bar = self._progress_bar(ratio_hit=ratio, milestone=m, width=12)
-
-        # Next targets (biar audience kebayang step berikutnya)
-        nxt1 = 2.0 if m < 2.0 else m + 1.0
-        nxt2 = nxt1 + 1.0
-        nxt_line = f"Next targets → **{nxt1:.0f}×** • **{nxt2:.0f}×**"
+        hh, rem = divmod(elapsed, 3600)
+        mm, ss = divmod(rem, 60)
+        elapsed_str = (f"{hh}h {mm}m {ss}s" if hh else f"{mm}m {ss}s")
 
+        # Header + body yang rapi & branded
         lines = [
-            headline,
-            f"{basis_line} • **{badge}**",
+            "💎 **MidasTouch Signal**",
+            f"**Milestone {m}× {basis_label}** • **Now:** ~{ratio:.2f}×",
             "",
-            name_line,
-            change,
-            t_since,
+            f"**{name}**",
+            f"{change}",
+            f"⏱️ Since call: {elapsed_str}",
             "",
-            f"{bar}  `{ratio:.2f}×`",
-            nxt_line,
-            "",
-            "Quick links:",
-            f"• 🔎 [Dexscreener]({dexs_link})",
-            f"• 🛒 [Trade on Axiom]({axiom_link})",
+            "Quick Actions:",
+            f"• 🔎 [View on Dexscreener]({dexs_link})",
+            f"• 🛒 [Trade with Axiom]({axiom_link})",
             "",
             f"CA: `{item.ca}`",
             "",
-            f"_{spice}  Signals ≠ certainty. DYOR & manage risk like a pro._",
+            "_Signals ≠ certainty. DYOR. Manage risk like a pro._"
         ]
         return "\n".join(lines)
 
-    # -------- Ratio & milestone logic --------
-    def _ratio(self, item: TrackItem, price: Optional[float], mcap: Optional[float]) -> Optional[float]:
-        if item.basis == "mcap":
-            if not (item.entry_mcap and mcap) or item.entry_mcap <= 0:
-                return None
-            return mcap / item.entry_mcap
-        else:
-            if not (item.entry_price and price) or item.entry_price <= 0:
-                return None
-            return price / item.entry_price
 
-    def arm(self, ca: str, origin_msg_id: Optional[int], basis: str,
-            entry_price: Optional[float], entry_mcap: Optional[float],
-            symbol_hint: Optional[str] = None):
-        it = TrackItem(
+    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:
+                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")
+
+        if item.basis == "mcap" and not item.entry_mcap:
+            print(f"[TRACK] {item.ca} no mcap available at entry. Fallback to price basis.")
+            item.basis = "price"
+
+        print(f"[TRACK] start {item.ca} basis={item.basis} entry_mcap={item.entry_mcap} entry_price={item.entry_price} poll={item.poll_secs}s")
+
+        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)
+                    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)
+                    continue
+                ratio = (cur_price / item.entry_price) if item.entry_price > 0 else 0.0
+
+            # === NEW: auto delete kalau drop >= threshold ===
+            if DROP_DELETE_RATIO > 0 and ratio <= DROP_DELETE_RATIO:
+                print(f"[TRACK] {item.ca} dropped to {ratio:.2f}× (≤ {DROP_DELETE_RATIO}×). Deleting origin & stopping.")
+                await self._delete_origin_and_replies(item.ca)
+                return  # stop tracking setelah dihapus
+
+            # --- milestone handling ---
+            while ratio >= item.next_milestone:
+                print(f"[TRACK] {item.ca} hit {item.next_milestone}x (ratio={ratio:.2f})")
+                text = self._milestone_text(item, item.next_milestone, ratio, cur_price, cur_mcap)
+                await self._send_reply_to_origin(item.ca, text)
+
+                # >>> VIDEO milestone ≥ 3× (atau sesuai VIDEO_MIN_MULTIPLE)
+                if item.next_milestone >= VIDEO_MIN_MULTIPLE:
+                    if os.path.isfile(VIDEO_PATH):
+                        try:
+                            key = ca_key_for_db(item.ca)
+                            reply_to_id = lookup_origin_msg_id(key) if key else None
+                            await self.client.send_file(
+                                self.announce_chat,
+                                VIDEO_PATH,
+                                caption="🚀 To the Moon! 🌕",
+                                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:
+                        print(f"[TRACK] VIDEO_PATH tidak ditemukan: {VIDEO_PATH}")
+
+                # 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,
+            basis=basis.lower(),
             entry_price=entry_price,
             entry_mcap=entry_mcap,
-            origin_msg_id=origin_msg_id,
+            poll_secs=poll_secs,
+            source_link=source_link,
             symbol_hint=symbol_hint,
+            next_milestone=REPLY_FROM_MULTIPLE,
         )
-        self._items[ca] = it
-        if origin_msg_id:
-            save_origin_msg_id(ca_key_for_db(ca), origin_msg_id)
-        print(f"[TRACK] armed {ca} basis={basis} entry_price={entry_price} entry_mcap={entry_mcap}")
-
-    def stop(self, ca: str):
-        t = self._tasks.pop(ca, None)
-        if t:
-            t.cancel()
-        self._items.pop(ca, None)
-        print(f"[TRACK] stopped {ca}")
-
-    async def _poll_loop(self, ca: str):
-        item = self._items.get(ca)
-        if not item:
-            return
-        # milestone seeds
-        milestones: List[float] = []
-        seed = max(REPLY_FROM_MULTIPLE, 1.5)
-        milestones.append(seed)
-        milestones.append(2.0)
-        milestones.append(3.0)
-        milestones.append(5.0)
-        milestones.append(8.0)
-        milestones.append(10.0)
-
-        # unlimited mode → lanjutkan kelipatan berikutnya dinamis
-        max_m = max(milestones)
-        try:
-            while True:
-                data = await self._dexscreener_price(ca)
-                if not data:
-                    await asyncio.sleep(TRACK_POLL_SECS)
-                    continue
-                price, symbol, mcap = data
-                if symbol and not item.symbol_hint:
-                    item.symbol_hint = symbol
-
-                r = self._ratio(item, price, mcap)
-                if r and r >= 1.0:
-                    # milestone baru
-                    new_hits: List[float] = []
-                    for m in milestones:
-                        if m in item.milestones_hit:
-                            continue
-                        if r >= m:
-                            new_hits.append(m)
-                    if new_hits:
-                        m = max(new_hits)
-                        item.milestones_hit.extend(new_hits)
-                        text = self._milestone_text(item, m, r, price, mcap)
-
-                        # attach video jika memenuhi
-                        files: Optional[List[str]] = None
-                        if r >= VIDEO_MIN_MULTIPLE:
-                            files = self._video_for_ratio(r)
-
-                        await self._send_reply_to_origin(ca, text, file_list=files)
-
-                        # tambahkan milestone lanjutan bila unlimited
-                        if UNLIMITED_MODE and m >= max_m:
-                            # strategi: tambah +1 ke depannya
-                            for k in range(1, 4):
-                                milestones.append(m + k)
-                            max_m = max(milestones)
-
-                await asyncio.sleep(TRACK_POLL_SECS)
-        except asyncio.CancelledError:
-            return
-        except Exception as e:
-            print(f"[TRACK] loop error for {ca}: {e}")
+        print(f"[TRACK] arming {ca} (basis={item.basis}, poll={item.poll_secs}s) from handler")
+        self._tasks[ca] = asyncio.create_task(self._loop(item))
 
-    def _video_for_ratio(self, ratio: float) -> Optional[List[str]]:
-        # Mapping sederhana; ganti path sesuai aset kamu
-        # (Kalau tidak punya, return None saja)
-        try:
-            if ratio >= 10:
-                return ["/app/assets/vid_x10.mp4"]
-            if ratio >= 5:
-                return ["/app/assets/vid_x5.mp4"]
-            if ratio >= 3:
-                return ["/app/assets/vid_x3.mp4"]
-        except Exception:
-            pass
-        return None
-
-    # Public: mulai tracking satu CA
-    def start(self, ca: str):
-        if ca in self._tasks:
-            return
-        t = asyncio.create_task(self._poll_loop(ca))
-        self._tasks[ca] = t
 
 # =========================
-# Parsers & handlers
+# Setup: attach to existing client from botsignal
 # =========================
-
-CA_RE = re.compile(r"\b[1-9A-HJ-NP-Za-km-z]{32,44}\b")  # kira-kira Solana base58 panjang 32..44
-
-def extract_ca(text: str) -> Optional[str]:
-    m = CA_RE.search(text or "")
-    return m.group(0) if m else None
-
-def extract_symbol(text: str) -> Optional[str]:
-    # coba cari uppercase 3-8 huruf di dekat CA / judul
-    m = re.search(r"\b([A-Z][A-Z0-9]{2,7})\b", text or "")
-    return m.group(1) if m else None
+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,)))
+    # NEW: dengarkan juga edit (tanpa backfill)
+    client.add_event_handler(on_new_message, events.MessageEdited(chats=(TARGET_CHAT,)))
+    print("[AUTOTRACK] attached to shared client; listening on", TARGET_CHAT)
 
 # =========================
-# Main bot
+# Client bootstrap
 # =========================
-async def main():
-    if not (API_ID and API_HASH and STRING_SESSION):
-        print("Please set API_ID, API_HASH, STRING_SESSION env.")
-        return
-
-    client = TelegramClient(StringSession(STRING_SESSION), API_ID, API_HASH)
-    await client.connect()
-
-    tracker = PriceTracker(client, TARGET_CHAT)
+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
 
-    @client.on(events.NewMessage(chats=(TARGET_CHAT,)))
-    async def on_new_message(evt):
+# =========================
+# Event handler: ONLY your group
+# =========================
+def _is_old_message(msg_dt: Optional[datetime]) -> bool:
+    if DISABLE_OLD_MESSAGE_CUTOFF:
+        return False
+    if not isinstance(msg_dt, datetime):
+        return False
+    return msg_dt.replace(tzinfo=timezone.utc) < (startup_time_utc - CUTOFF_BUFFER)
+
+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 on_new_message(event):
+    try:
+        # Handler-side filter: only process messages from TARGET_CHAT
         try:
-            if not evt.message or not evt.message.message:
+            target_user = _parse_target_username(TARGET_CHAT)
+            chat = await event.get_chat()
+            uname = (getattr(chat, 'username', None) or '')
+            if target_user and (uname.lower() != target_user):
                 return
-            # deteksi CA dari pesan baru (tanpa backfill)
-            text = evt.message.message
-            ca = extract_ca(text)
-            if not ca:
-                return
-            # jika sudah armed, skip
-            if ca in tracker._items:
-                return
-
-            # seed symbol & entry price/mcap
-            data = await tracker._dexscreener_price(ca)
-            if not data:
-                return
-            price, symbol, mcap = data
-
-            # pilih basis default mcap jika ada, else price
-            basis = "mcap" if mcap else "price"
-
-            tracker.arm(
-                ca=ca,
-                origin_msg_id=evt.message.id,
-                basis=basis,
-                entry_price=price,
-                entry_mcap=mcap,
-                symbol_hint=symbol,
-            )
-
-            # start polling loop
-            tracker.start(ca)
+        except Exception:
+            # If we cannot resolve chat username, continue (best-effort)
+            pass
+        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
 
-            # Bila sudah > 1.5× langsung reply (opsional)—di-flow ini kita biarkan loop yang menembakkan
-        except Exception as e:
-            print(f"[EVENT] on_new_message error: {e}")
+        # Log arming point for traceability
+        print(f"[TRACK] arming {ca} from message id={getattr(msg, 'id', None)} (edited={isinstance(event, events.MessageEdited.Event)})")
 
-    # Dengerin juga edit (tanpa backfill) — misal ada CA yang ditambahkan saat edit
-    @client.on(events.MessageEdited(chats=(TARGET_CHAT,)))
-    async def on_msg_edited(evt):
+        # Optional: link back to source (tidak dipakai di teks sekarang, tapi disimpan kalau perlu)
+        source_link = None
         try:
-            if not evt.message or not evt.message.message:
-                return
-            text = evt.message.message
-            ca = extract_ca(text)
-            if not ca or ca in tracker._items:
-                return
-            data = await tracker._dexscreener_price(ca)
-            if not data:
-                return
-            price, symbol, mcap = data
-            basis = "mcap" if mcap else "price"
-
-            tracker.arm(
-                ca=ca,
-                origin_msg_id=evt.message.id,
-                basis=basis,
-                entry_price=price,
-                entry_mcap=mcap,
-                symbol_hint=symbol,
-            )
-            tracker.start(ca)
-        except Exception as e:
-            print(f"[EVENT] on_msg_edited error: {e}")
+            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}")
 
-    print("AutoTrack running (unlimited milestones; first reply at ≥1.5×). Listening ONLY your group for NEW/EDITED messages...")
+# =========================
+# 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/EDITED messages...")
+    client.add_event_handler(on_new_message, events.NewMessage(chats=(TARGET_CHAT,)))
+    # NEW: dengarkan juga edit (tanpa backfill)
+    client.add_event_handler(on_new_message, events.MessageEdited(chats=(TARGET_CHAT,)))
     await client.run_until_disconnected()
 
 if __name__ == "__main__":