Update bot_core.py

bot_core.py

@@ -4,7 +4,6 @@ from telethon import TelegramClient, events
 from telethon.sessions import StringSession
 from telethon.errors.rpcerrorlist import FloodWaitError
 
-
 # ========= LOGGING =========
 LOG_LEVEL = os.environ.get("LOG_LEVEL", "INFO").upper()
 logger = logging.getLogger("midastouch-bot")
@@ -24,7 +23,6 @@ API_ID   = int(os.environ.get("API_ID", "0"))
 API_HASH = os.environ.get("API_HASH", "")
 STRING_SESSION = os.environ.get("STRING_SESSION", "")
 
-# Comma-separated; each item may be a full t.me URL or @username or bare username
 SOURCE_CHATS_ENV = os.environ.get("SOURCE_CHATS", "@KOLscopeAlertsBot")
 SOURCE_CHATS = [s.strip() for s in SOURCE_CHATS_ENV.split(",") if s.strip()]
 TARGET_CHAT = os.environ.get("TARGET_CHAT", "@solana_trojanbot").strip()
@@ -37,8 +35,8 @@ RETRY_LABELS = [x.strip() for x in os.environ.get(
 RETRY_MAX_ATTEMPTS    = int(os.environ.get("RETRY_MAX_ATTEMPTS", "12"))
 RETRY_SLEEP_SECONDS   = float(os.environ.get("RETRY_SLEEP_SECONDS", "1.2"))
 RETRY_OVERALL_TIMEOUT = float(os.environ.get("RETRY_OVERALL_TIMEOUT", "60"))
-
-DEDUP_TTL_MINUTES     = int(os.environ.get("DEDUP_TTL_MINUTES", "600"))  # 10 jam default
+DEDUP_TTL_MINUTES     = int(os.environ.get("DEDUP_TTL_MINUTES", "600"))  # 10 jam
+MIN_MCAP_USD          = float(os.environ.get("MIN_MCAP_USD", "70000"))   # batas minimal MC
 
 if not (API_ID and API_HASH and STRING_SESSION):
     raise RuntimeError("API_ID/API_HASH/STRING_SESSION belum di-set di Secrets.")
@@ -49,8 +47,8 @@ nest_asyncio.apply()
 CA_SOL_RE = re.compile(r"\b([1-9A-HJ-NP-Za-km-z]{32,44})(?:pump)?\b")
 CA_EVM_RE = re.compile(r"\b0x[a-fA-F0-9]{40}\b")
 
-BUY_PAT     = re.compile(r"(?i)buy")
-RETRY_PAT   = re.compile(r"(?i)(" + "|".join(map(re.escape, RETRY_LABELS)) + r")") if RETRY_LABELS else re.compile(r"$^")
+BUY_PAT   = re.compile(r"(?i)buy")
+RETRY_PAT = re.compile(r"(?i)(" + "|".join(map(re.escape, RETRY_LABELS)) + r")") if RETRY_LABELS else re.compile(r"$^")
 
 # ========= UTIL =========
 def _normalize_chat(s: str) -> str:
@@ -91,10 +89,36 @@ def find_first_ca(text: str) -> Optional[Tuple[str, str]]:
     logger.info("CA  | ditemukan chain=%s addr=%s", chain, addr)
     return chain, addr
 
+# ========= MCAP PARSER =========
+_MC_UNITS = {"K": 1e3, "M": 1e6, "B": 1e9}
+_MC_PAT_NUM_THEN_TAG = re.compile(r"(?i)\b\$?\s*([\d][\d.,]*)\s*([KMB])?\s*(?:mcap|mc|market\s*cap)\b")
+_MC_PAT_TAG_THEN_NUM = re.compile(r"(?i)\b(?:mcap|mc|market\s*cap)\s*[:@]?\s*\$?\s*([\d][\d.,]*)\s*([KMB])?\b")
+
+def _to_float_num(num_str: str) -> float:
+    s = num_str.strip().replace(" ", "").replace("$", "")
+    has_dot, has_comma = "." in s, "," in s
+    if has_dot and has_comma:
+        s = s.replace(",", "")
+    elif has_comma and not has_dot:
+        s = s.replace(",", ".")
+    return float(s)
+
+def parse_mcap_usd(text: str) -> Optional[float]:
+    if not text:
+        return None
+    for pat in (_MC_PAT_NUM_THEN_TAG, _MC_PAT_TAG_THEN_NUM):
+        m = pat.search(text)
+        if m:
+            raw_num = m.group(1)
+            unit = (m.group(2) or "").upper()
+            base = _to_float_num(raw_num)
+            mult = _MC_UNITS.get(unit, 1.0)
+            return base * mult
+    return None
+
 # ========= STATE =========
 client = TelegramClient(StringSession(STRING_SESSION), API_ID, API_HASH)
 ca_queue: "asyncio.Queue[str]" = asyncio.Queue()
-# addr -> (timestamp, first_source_label)
 recent_ca_info: dict[str, tuple[float, str]] = {}
 
 def _is_recent(addr: str) -> bool:
@@ -104,7 +128,7 @@ def _is_recent(addr: str) -> bool:
 def _mark_ca(addr: str, source_label: str):
     recent_ca_info[addr] = (time.time(), source_label)
 
-# ========= BOT FLOW HELPERS =========
+# ========= FLOW =========
 async def refresh_message(msg):
     return await client.get_messages(msg.chat_id, ids=msg.id)
 
@@ -114,10 +138,8 @@ async def wait_new_keyboard(chat, *, min_id: int, timeout=25, interval=0.8):
         msgs = await client.get_messages(chat, limit=8)
         for m in msgs:
             if m.id > min_id and m.buttons:
-                logger.debug("KB  | keyboard baru id=%s", m.id)
                 return m
         await asyncio.sleep(interval)
-    logger.warning("KB  | tidak menemukan keyboard (timeout=%ss)", timeout)
     return None
 
 async def click_first_match(msg, pat) -> bool:
@@ -130,134 +152,44 @@ async def click_first_match(msg, pat) -> bool:
         for j, btn in enumerate(row):
             label = (getattr(btn, "text", "") or "").strip()
             if label and pat.search(label):
-                logger.info("UI  | klik tombol: %s (i=%d, j=%d)", label, i, j)
                 await msg.click(i, j)
                 return True
     return False
 
-async def search_latest_with_button(chat, pat, *, min_id: int, limit=10):
-    msgs = await client.get_messages(chat, limit=limit)
-    for m in msgs:
-        if m.id >= min_id and m.buttons:
-            m2 = await client.get_messages(chat, ids=m.id)
-            if m2 and await click_first_match(m2, pat):
-                logger.debug("UI  | tombol ditemukan di pesan id=%s", m.id)
-                return m2
-    return None
-
-async def click_retry_until_gone(anchor_msg, *, baseline_id: int) -> bool:
-    attempts = 0
-    started = time.monotonic()
-    msg_kb = anchor_msg
-    while attempts < RETRY_MAX_ATTEMPTS and (time.monotonic() - started) < (RETRY_OVERALL_TIMEOUT):
-        msg_kb = await refresh_message(msg_kb)
-        if await click_first_match(msg_kb, RETRY_PAT):
-            attempts += 1
-            logger.info("RET | klik Retry ke-%d", attempts)
-            await asyncio.sleep(RETRY_SLEEP_SECONDS)
-            continue
-
-        msgs = await client.get_messages(TARGET_CHAT, limit=8)
-        for m in msgs:
-            if m.id >= baseline_id and m.buttons:
-                m2 = await client.get_messages(TARGET_CHAT, ids=m.id)
-                if m2 and await click_first_match(m2, RETRY_PAT):
-                    attempts += 1
-                    baseline_id = max(baseline_id, m2.id)
-                    logger.info("RET | klik Retry di msg.id=%s (total=%d)", m.id, attempts)
-                    await asyncio.sleep(RETRY_SLEEP_SECONDS)
-                    break
-        else:
-            break
-    logger.info("RET | selesai (attempts=%d)", attempts)
-    return True
-
 async def buy_flow_with_ca(addr: str):
     logger.info("FLOW| start buy_flow CA=%s", addr)
     last = await client.get_messages(TARGET_CHAT, limit=1)
     baseline_id = last[0].id if last else 0
-
     await client.send_message(TARGET_CHAT, addr)
-    logger.info("SEND| CA terkirim ke target bot")
-
     msg_kb = await wait_new_keyboard(TARGET_CHAT, min_id=baseline_id, timeout=25)
     if not msg_kb:
-        logger.warning("KB  | no keyboard → fallback /start")
-        await client.send_message(TARGET_CHAT, "/start")
-        await asyncio.sleep(1.0)
-        await client.send_message(TARGET_CHAT, addr)
-        msg_kb = await wait_new_keyboard(TARGET_CHAT, min_id=baseline_id, timeout=25)
-        if not msg_kb:
-            logger.error("KB  | gagal dapat keyboard setelah fallback")
-            return
-
-    if AMOUNT_LABEL:
-        ok_amt = await click_first_match(msg_kb, re.compile(re.escape(AMOUNT_LABEL), re.IGNORECASE))
-        logger.info("UI  | pilih amount '%s' → %s", AMOUNT_LABEL, "OK" if ok_amt else "MISS")
-        if ok_amt:
-            await asyncio.sleep(1.0)
-            msg2 = await wait_new_keyboard(TARGET_CHAT, min_id=baseline_id, timeout=12)
-            msg_kb = msg2 or await refresh_message(msg_kb)
-            baseline_id = max(baseline_id, getattr(msg_kb, "id", baseline_id))
-
-    logger.info("STEP| klik BUY")
-    ok_buy = await click_first_match(msg_kb, BUY_PAT)
-    if not ok_buy:
-        hit = await search_latest_with_button(TARGET_CHAT, BUY_PAT, min_id=baseline_id, limit=10)
-        if hit:
-            msg_kb = hit
-            ok_buy = True
-            logger.info("UI  | BUY ditemukan di pesan lain")
-    if not ok_buy and getattr(msg_kb, "buttons", None) and msg_kb.buttons[-1]:
-        try:
-            await msg_kb.click(len(msg_kb.buttons) - 1, 0)
-            ok_buy = True
-            logger.info("FALL| klik tombol terakhir sebagai BUY")
-        except Exception as e:
-            logger.debug("FALL| gagal klik tombol terakhir: %s", e)
-
-    if not ok_buy:
-        logger.warning("BUY | tombol tidak ditemukan → ulangi /start")
-        await client.send_message(TARGET_CHAT, "/start")
-        await asyncio.sleep(1.0)
-        await client.send_message(TARGET_CHAT, addr)
-        msg_kb2 = await wait_new_keyboard(TARGET_CHAT, min_id=baseline_id, timeout=25)
-        msg_kb = msg_kb2 or msg_kb
-        if not await click_first_match(msg_kb, BUY_PAT):
-            hit2 = await search_latest_with_button(TARGET_CHAT, BUY_PAT, min_id=baseline_id, limit=10)
-            if not hit2:
-                logger.error("BUY | tetap gagal setelah ulang")
-                return
-            msg_kb = hit2
-            logger.info("UI  | BUY ditemukan setelah ulang")
-
-    await asyncio.sleep(1.0)
-    await click_retry_until_gone(msg_kb, baseline_id=baseline_id)
+        return
+    await click_first_match(msg_kb, BUY_PAT)
     logger.info("DONE| buy_flow selesai untuk CA=%s", addr)
 
 # ========= ACCEPT / QUEUE =========
-
 def _accept_ca(addr: str, current_source: str) -> bool:
     if not addr:
         return False
     if _is_recent(addr):
-        ts, first_src = recent_ca_info.get(addr, (0.0, "?"))
-        age = time.time() - ts
-        logger.info(
-            "SKIP| CA %s duplikat (age=%.1fs < %ds) pertama dari [%s], sekarang dari [%s]",
-            addr, age, DEDUP_TTL_MINUTES * 60, first_src, current_source
-        )
         return False
     _mark_ca(addr, current_source)
     return True
 
 # ========= EVENT HANDLER =========
-# Attach handler directly to the client (fix: decorator must bind to client)
-@client.on(events.NewMessage(chats=[_normalize_chat(s) for s in SOURCE_CHATS]))
+@events.register(events.NewMessage(chats=[_normalize_chat(s) for s in SOURCE_CHATS]))
 async def on_message_from_sources(event: events.NewMessage.Event):
     src_label = _label_chat_from_event(event)
     txt = (event.raw_text or "").strip()
-    logger.info("EVNT| pesan baru dari %s (len=%d)", src_label, len(txt))
+    logger.info("EVNT| pesan baru dari %s", src_label)
+
+    mc_usd = parse_mcap_usd(txt)
+    if mc_usd is not None:
+        if mc_usd < MIN_MCAP_USD:
+            logger.info("SKIP| MC=%.2f < %.2f → abaikan", mc_usd, MIN_MCAP_USD)
+            return
+        else:
+            logger.info("PASS| MC=%.2f ≥ %.2f → lanjutkan", mc_usd, MIN_MCAP_USD)
 
     found = find_first_ca(txt)
     if not found:
@@ -283,18 +215,13 @@ async def _worker():
             ca_queue.task_done()
 
 async def start_bot_background():
-    logger.info(
-        "BOOT| starting bot (sources=%s, target=%s, dedup=%d min, log=%s)",
-        ",".join([_normalize_chat(s) for s in SOURCE_CHATS]), TARGET_CHAT, DEDUP_TTL_MINUTES, LOG_LEVEL
-    )
+    logger.info("BOOT| starting bot (sources=%s, target=%s)", ",".join(SOURCE_CHATS), TARGET_CHAT)
     await client.start()
     asyncio.create_task(_worker())
 
 async def stop_bot():
-    logger.info("BOOT| stopping bot…")
     await client.disconnect()
 
-# Optional: quick runner for manual testing
 if __name__ == "__main__":
     async def _main():
         await start_bot_background()