uni-exec-engine 0.2.0__py3-none-any.whl

uniswap_autopilot/execute/telegram_confirm.py

@@ -0,0 +1,272 @@
+#!/usr/bin/env python3
+"""
+Telegram confirmation helper for Uniswap trade execution.
+
+Sends trade details to Telegram with inline Approve/Reject buttons,
+then polls for callback response.  Pure stdlib — no curl dependency.
+
+Usage:
+    from uniswap_autopilot.execute.telegram_confirm import request_trade_confirmation
+    if not request_trade_confirmation(trade_details):
+        sys.exit(0)
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import tempfile
+import time
+from pathlib import Path
+from typing import Any
+from urllib.error import HTTPError, URLError
+from urllib.request import Request, urlopen
+
+# ── config ──────────────────────────────────────────────────────────────────
+
+
+def _read_config_file(config_path: str | None = None) -> tuple[str, str, list[str]]:
+    """Return (bot_token, chat_id, allowed_user_ids) from a JSON config file.
+
+    Config is expected to be a dict with optional nested keys, e.g.
+    {"botToken": "...", "chatId": "...", "allowFrom": [...]}  or
+    {"channels": {"telegram": {"botToken": "...", "allowFrom": [...]}}}
+    """
+    path = Path(config_path or os.environ.get("TELEGRAM_CONFIG_PATH", ""))
+    if not path.is_file():
+        raise FileNotFoundError(f"Config file not found: {path}")
+
+    with open(path) as f:
+        cfg = json.load(f)
+
+    bot_token = cfg.get("botToken", "")
+    chat_id = cfg.get("chatId", "")
+    allow_from = cfg.get("allowFrom") or []
+
+    if not bot_token:
+        tg = cfg.get("channels", {}).get("telegram", {})
+        bot_token = tg.get("botToken", "")
+        if not chat_id:
+            allow = tg.get("allowFrom", [])
+            chat_id = str(allow[-1]) if allow else ""
+        if not allow_from:
+            allow_from = tg.get("allowFrom") or []
+
+    if not bot_token:
+        raise RuntimeError("Telegram botToken not found in config file")
+    return bot_token, chat_id, [str(x) for x in allow_from]
+
+
+BOT_TOKEN, CHAT_ID = "", ""
+ALLOWED_USER_IDS: list[str] = []
+
+
+def _ensure_config():
+    """Lazily load config on first use to avoid import-time failure."""
+    global BOT_TOKEN, CHAT_ID, ALLOWED_USER_IDS
+    if BOT_TOKEN:
+        return
+    BOT_TOKEN = os.environ.get("TELEGRAM_BOT_TOKEN", "")
+    CHAT_ID = os.environ.get("TELEGRAM_CHAT_ID", "")
+    env_allow = os.environ.get("TELEGRAM_ALLOWED_USER_IDS", "")
+    if env_allow:
+        ALLOWED_USER_IDS = [x.strip() for x in env_allow.split(",") if x.strip()]
+    if BOT_TOKEN and CHAT_ID and ALLOWED_USER_IDS:
+        return
+    try:
+        token, chat, allow = _read_config_file()
+        BOT_TOKEN = BOT_TOKEN or token
+        CHAT_ID = CHAT_ID or chat
+        if not ALLOWED_USER_IDS:
+            ALLOWED_USER_IDS = allow
+    except (FileNotFoundError, RuntimeError):
+        pass
+
+
+def _state_file(confirmation_id: str | None = None) -> Path:
+    """Cross-platform state file path.
+
+    The previous implementation used a single shared file for ALL
+    confirmation requests, which made it impossible to run concurrent trade
+    flows safely (one would overwrite another's state). We now namespace the
+    file by ``confirmation_id`` so each request owns its own state slot.
+    """
+    name = "uniswap_trade_confirmation_state"
+    if confirmation_id:
+        # Strip any characters that would be problematic on disk.
+        safe = "".join(c for c in confirmation_id if c.isalnum() or c in ("_", "-"))
+        name = f"{name}_{safe}"
+    return Path(tempfile.gettempdir()) / f"{name}.json"
+
+
+# ── helpers ─────────────────────────────────────────────────────────────────
+
+
+def _tg_api(method: str, payload: dict[str, Any]) -> dict[str, Any]:
+    """Call Telegram Bot API via urllib (no curl dependency)."""
+    _ensure_config()
+    if not BOT_TOKEN:
+        raise RuntimeError(
+            "Telegram bot token not configured. "
+            "Set TELEGRAM_BOT_TOKEN and TELEGRAM_CHAT_ID env vars, "
+            "or provide a config file via TELEGRAM_CONFIG_PATH"
+        )
+    url = f"https://api.telegram.org/bot{BOT_TOKEN}/{method}"
+    data = json.dumps(payload, ensure_ascii=False).encode("utf-8")
+    req = Request(url, data=data, headers={"Content-Type": "application/json"})
+    try:
+        with urlopen(req, timeout=15) as resp:
+            return json.loads(resp.read())
+    except (HTTPError, URLError) as e:
+        return {"ok": False, "error": str(e)}
+
+
+def _poll_updates(offset: int | None = None, timeout: int = 2) -> list[dict]:
+    """Short-poll getUpdates for callback_query only."""
+    payload: dict[str, Any] = {
+        "allowed_updates": ["callback_query"],
+        "timeout": timeout,
+    }
+    if offset is not None:
+        payload["offset"] = offset
+    resp = _tg_api("getUpdates", payload)
+    return resp.get("result", [])
+
+
+# ── main API ────────────────────────────────────────────────────────────────
+
+
+def request_trade_confirmation(
+    trade_details: dict[str, Any],
+    timeout_seconds: int = 300,
+) -> bool:
+    """
+    Send trade confirmation to Telegram and wait for user response.
+
+    Returns True if approved, False if rejected or timeout.
+    """
+    _ensure_config()
+    confirmation_id = f"uni_{int(time.time()) % 100000:05d}"
+
+    lines = [
+        "🔍 *Uniswap Trade Confirmation*",
+        "",
+        f"📍 Chain: `{trade_details.get('chain', '?')}`",
+        f"🔄 {trade_details.get('tokenIn', '?')} → {trade_details.get('tokenOut', '?')}",
+        f"💰 {trade_details.get('amountIn', '?')} → {trade_details.get('amountOut', '?')}",
+        "",
+        f"⏳ Timeout: {timeout_seconds // 60} min",
+        f"🆔 `{confirmation_id}`",
+    ]
+
+    payload = {
+        "chat_id": CHAT_ID,
+        "text": "\n".join(lines),
+        "parse_mode": "Markdown",
+        "reply_markup": {
+            "inline_keyboard": [[
+                {"text": "✅ Approve", "callback_data": f"uap_{confirmation_id}"},
+                {"text": "❌ Reject", "callback_data": f"urj_{confirmation_id}"},
+            ]]
+        },
+    }
+
+    resp = _tg_api("sendMessage", payload)
+    if not resp.get("ok"):
+        print(f"⚠️ Telegram sendMessage failed: {resp}")
+        return False
+
+    msg_id = resp["result"]["message_id"]
+    print(f"📤 Confirmation sent (msg_id={msg_id}, id={confirmation_id})")
+
+    state = {
+        "confirmation_id": confirmation_id,
+        "status": "pending",
+        "created_at": time.time(),
+    }
+    state_path = _state_file(confirmation_id)
+    state_path.write_text(json.dumps(state))
+
+    deadline = time.time() + timeout_seconds
+    last_offset: int | None = None
+
+    while time.time() < deadline:
+        try:
+            updates = _poll_updates(
+                offset=last_offset,
+                timeout=min(5, int(deadline - time.time())),
+            )
+        except Exception as e:
+            print(f"⚠️ Poll error: {e}, retrying...")
+            time.sleep(2)
+            continue
+
+        for upd in updates:
+            last_offset = upd["update_id"] + 1
+            cb = upd.get("callback_query")
+            if not cb:
+                continue
+            from_user = cb.get("from", {}) if isinstance(cb, dict) else {}
+            from_id = str(from_user.get("id", "")).strip()
+            if ALLOWED_USER_IDS and from_id not in ALLOWED_USER_IDS:
+                _tg_api("answerCallbackQuery", {
+                    "callback_query_id": cb.get("id", ""),
+                    "text": "Not authorized",
+                    "show_alert": True,
+                })
+                continue
+            data = cb.get("data", "")
+            if data in (f"uap_{confirmation_id}", f"urj_{confirmation_id}"):
+                is_approved = data.startswith("uap_")
+                decision = "✅ Approved" if is_approved else "❌ Rejected"
+                state["status"] = "approved" if is_approved else "rejected"
+                state["resolved_at"] = time.time()
+                state_path.write_text(json.dumps(state))
+                _tg_api("editMessageReplyMarkup", {
+                    "chat_id": CHAT_ID,
+                    "message_id": msg_id,
+                })
+                _tg_api("editMessageText", {
+                    "chat_id": CHAT_ID,
+                    "message_id": msg_id,
+                    "text": "\n".join(lines) + "\n\n🔒 *Decision: " + decision + "*",
+                    "parse_mode": "Markdown",
+                })
+                _tg_api("answerCallbackQuery", {
+                    "callback_query_id": cb["id"],
+                })
+                print(f"{decision} by user")
+                return is_approved
+
+        time.sleep(0.5)
+
+    print("⏰ Confirmation timeout")
+    state["status"] = "timeout"
+    state_path.write_text(json.dumps(state))
+    return False
+
+
+# ── CLI test ────────────────────────────────────────────────────────────────
+
+
+def main() -> None:
+    import argparse
+    parser = argparse.ArgumentParser(description="Test Telegram trade confirmation")
+    parser.add_argument("--test", action="store_true")
+    args = parser.parse_args()
+
+    if args.test:
+        ok = request_trade_confirmation({
+            "chain": "Base",
+            "tokenIn": "ETH",
+            "tokenOut": "USDC",
+            "amountIn": "0.1 ETH",
+            "amountOut": "~200 USDC",
+        }, timeout_seconds=120)
+        print(f"\nResult: {'APPROVED' if ok else 'REJECTED/TIMEOUT'}")
+    else:
+        print("Use --test to send a test confirmation")
+
+
+if __name__ == "__main__":
+    main()

uniswap_autopilot/lp/compare_pools.py

@@ -0,0 +1,338 @@
+#!/usr/bin/env python3
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+from pathlib import Path
+from typing import Any
+
+
+from uniswap_autopilot.common.common import (
+    V3_FEE_TIERS,
+    dump_json,
+    load_local_env,
+    normalize_chain,
+    resolve_token,
+    sort_token_addresses,
+)
+from uniswap_autopilot.lp.v3.pool import query_pool_full_info
+from uniswap_autopilot.search.search import _ds_lookup, _fetch_json
+
+DEFILLAMA_YIELDS_URL = "https://yields.llama.fi/pools"
+
+DEFILLAMA_CHAIN_MAP: dict[str, str] = {
+    "avalanche": "avax",
+}
+
+
+def _defillama_chain_name(chain_key: str) -> str:
+    mapped = DEFILLAMA_CHAIN_MAP.get(chain_key, chain_key)
+    return mapped.capitalize()
+
+
+def fetch_defillama_yields(chain: str) -> dict[str, dict]:
+    chain_key = chain.strip().lower()
+    dl_chain = _defillama_chain_name(chain_key)
+
+    try:
+        data = _fetch_json(DEFILLAMA_YIELDS_URL, timeout=30)
+    except Exception as exc:
+        print(f"  [warn] DefiLlama yields fetch failed: {exc}", file=sys.stderr)
+        return {}
+
+    pools = data.get("data", [])
+    result: dict[str, dict] = {}
+    for pool in pools:
+        if pool.get("project") != "uniswap-v3":
+            continue
+        if (pool.get("chain") or "").lower() != dl_chain.lower():
+            continue
+        pool_addr = (pool.get("pool") or "").lower()
+        if not pool_addr:
+            continue
+        result[pool_addr] = {
+            "apy": pool.get("apy"),
+            "apyBase": pool.get("apyBase"),
+            "tvlUsd": pool.get("tvlUsd"),
+            "volumeUsd1d": pool.get("volumeUsd1d"),
+        }
+    return result
+
+
+def fetch_dexscreener_pair(
+    chain: str, token0_addr: str, token1_addr: str
+) -> dict | None:
+    try:
+        ds = _ds_lookup(chain, token0_addr)
+    except Exception:
+        ds = None
+    if not ds:
+        try:
+            ds = _ds_lookup(chain, token1_addr)
+        except Exception:
+            return None
+    if not ds:
+        return None
+    return {
+        "volume24h": ds.get("volume24h"),
+        "liquidityUsd": ds.get("liquidityUsd"),
+        "priceUsd": ds.get("priceUsd"),
+    }
+
+
+def _fmt_usd(val: float | None) -> str:
+    if val is None:
+        return "-"
+    if val >= 1_000_000_000:
+        return f"${val / 1_000_000_000:.2f}B"
+    if val >= 1_000_000:
+        return f"${val / 1_000_000:.2f}M"
+    if val >= 1_000:
+        return f"${val / 1_000:.1f}K"
+    if val > 0:
+        return f"${val:.4f}"
+    return "-"
+
+
+def _fmt_pct(val: float | None) -> str:
+    if val is None:
+        return "-"
+    return f"{val:.2f}%"
+
+
+def _safe_float(val: Any, default: float = 0.0) -> float:
+    if val is None:
+        return default
+    try:
+        return float(val)
+    except (ValueError, TypeError):
+        return default
+
+
+def compare_pools_for_pair(
+    chain_name: str, token_a: str, token_b: str, rpc_url: str | None
+) -> dict[str, Any]:
+    chain = normalize_chain(chain_name)
+    token_a_info = resolve_token(chain, token_a, rpc_url)
+    token_b_info = resolve_token(chain, token_b, rpc_url)
+
+    def _addr_or_wrapped(info: dict[str, Any]) -> str:
+        addr = info["address"]
+        if addr != "NATIVE":
+            return addr
+        wrapped = chain.tokens.get(chain.wrapped_native_symbol.upper())
+        if wrapped:
+            return wrapped.address
+        wtoken = resolve_token(chain, chain.wrapped_native_symbol, rpc_url)
+        return wtoken["address"]
+
+    addr_a = _addr_or_wrapped(token_a_info)
+    addr_b = _addr_or_wrapped(token_b_info)
+    token0_addr, token1_addr = sort_token_addresses(addr_a, addr_b)
+
+    pool_results: list[dict[str, Any]] = []
+    fee_tiers_sorted = sorted(V3_FEE_TIERS)
+
+    for fee_tier in fee_tiers_sorted:
+        try:
+            info = query_pool_full_info(
+                chain_name, token_a, token_b, fee_tier, rpc_url
+            )
+        except Exception as exc:
+            pool_results.append({
+                "feeTier": fee_tier,
+                "feePct": f"{fee_tier / 10000:.2f}%",
+                "exists": False,
+                "error": str(exc),
+            })
+            continue
+
+        if not info.get("exists"):
+            pool_results.append({
+                "feeTier": fee_tier,
+                "feePct": f"{fee_tier / 10000:.2f}%",
+                "poolAddress": None,
+                "exists": False,
+            })
+            continue
+
+        pool_addr = info.get("poolAddress", "").lower()
+        pool_results.append({
+            "feeTier": fee_tier,
+            "feePct": f"{fee_tier / 10000:.2f}%",
+            "poolAddress": info.get("poolAddress"),
+            "exists": True,
+            "currentTick": info.get("currentTick"),
+            "currentPrice": info.get("currentPrice"),
+            "liquidity": info.get("liquidity"),
+            "_addr_lower": pool_addr,
+        })
+
+    # Fetch DefiLlama yields for the chain
+    dl_yields = fetch_defillama_yields(chain_name)
+
+    # Fetch DexScreener data for the pair
+    ds_data = fetch_dexscreener_pair(chain.key, token0_addr, token1_addr)
+
+    # Enrich pool results with yield and volume data
+    for pr in pool_results:
+        if not pr.get("exists"):
+            pr["tvlUsd"] = None
+            pr["volume24h"] = None
+            pr["apy"] = None
+            pr["apyBase"] = None
+            continue
+
+        addr_lower = pr.get("_addr_lower", "")
+        dl = dl_yields.get(addr_lower, {})
+        pr["tvlUsd"] = dl.get("tvlUsd")
+        pr["volumeUsd1d"] = dl.get("volumeUsd1d")
+        pr["apy"] = dl.get("apy")
+        pr["apyBase"] = dl.get("apyBase")
+
+        if ds_data:
+            pr["dexVolume24h"] = ds_data.get("volume24h")
+            pr["dexLiquidityUsd"] = ds_data.get("liquidityUsd")
+            pr["dexPriceUsd"] = ds_data.get("priceUsd")
+        else:
+            pr["dexVolume24h"] = None
+            pr["dexLiquidityUsd"] = None
+            pr["dexPriceUsd"] = None
+
+        # Clean internal key
+        pr.pop("_addr_lower", None)
+
+    # Determine recommendation
+    eligible = [pr for pr in pool_results if pr.get("exists")]
+    recommendation = None
+    if eligible:
+        high_tvl = [p for p in eligible if (_safe_float(p.get("tvlUsd")) or _safe_float(p.get("dexLiquidityUsd"))) > 100_000]
+        if high_tvl:
+            best = max(high_tvl, key=lambda p: _safe_float(p.get("apy")))
+            reason = "highest APY"
+        else:
+            best = max(eligible, key=lambda p: _safe_float(p.get("tvlUsd")) or _safe_float(p.get("dexLiquidityUsd")))
+            reason = "highest TVL (no pool above $100K TVL)"
+        recommendation = {
+            "feeTier": best["feeTier"],
+            "feePct": best["feePct"],
+            "poolAddress": best["poolAddress"],
+            "reason": reason,
+        }
+
+    return {
+        "action": "compare_pools",
+        "chain": {"key": chain.key, "chainId": chain.chain_id},
+        "tokenA": token_a_info,
+        "tokenB": token_b_info,
+        "token0": token0_addr,
+        "token1": token1_addr,
+        "pools": pool_results,
+        "recommendation": recommendation,
+    }
+
+
+def _print_comparison_table(result: dict[str, Any]) -> None:
+    chain = result["chain"]["key"]
+    ta = result["tokenA"]["symbol"]
+    tb = result["tokenB"]["symbol"]
+    print(f"\nPool Comparison: {ta}/{tb} on {chain}")
+    print()
+    header = (
+        f"{'Fee Tier':<10} "
+        f"{'Pool Address':<22} "
+        f"{'TVL':>14} "
+        f"{'Volume 24h':>14} "
+        f"{'APY':>10} "
+        f"{'Liquidity':>16}"
+    )
+    print(header)
+    print("-" * len(header) + "-" * 10)
+
+    for pool in result["pools"]:
+        fee_pct = pool["feePct"]
+        if not pool.get("exists"):
+            print(
+                f"{fee_pct:<10} "
+                f"{'not found':<22} "
+                f"{'-':>14} "
+                f"{'-':>14} "
+                f"{'-':>10} "
+                f"{'-':>16}"
+            )
+            continue
+
+        addr = pool.get("poolAddress", "")
+        addr_short = addr[:8] + "..." + addr[-4:] if len(addr) > 14 else addr
+        tvl = _safe_float(pool.get("tvlUsd")) or _safe_float(pool.get("dexLiquidityUsd"))
+        vol = _safe_float(pool.get("volumeUsd1d")) or _safe_float(pool.get("dexVolume24h"))
+        apy = pool.get("apy")
+        liq = pool.get("liquidity", "-")
+
+        tvl_str = _fmt_usd(tvl) if tvl > 0 else "-"
+        vol_str = _fmt_usd(vol) if vol > 0 else "-"
+        apy_str = _fmt_pct(apy) if apy is not None else "-"
+        liq_str = str(liq) if liq != "-" else "-"
+
+        print(
+            f"{fee_pct:<10} "
+            f"{addr_short:<22} "
+            f"{tvl_str:>14} "
+            f"{vol_str:>14} "
+            f"{apy_str:>10} "
+            f"{liq_str:>16}"
+        )
+
+    print("-" * len(header) + "-" * 10)
+
+    rec = result.get("recommendation")
+    if rec:
+        print(f"\nRecommended: {rec['feePct']} ({rec['reason']})")
+        print(f"  Pool: {rec['poolAddress']}")
+    else:
+        print("\nNo recommendation (no pools found)")
+
+    print()
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(
+        description="Compare Uniswap v3 pools across fee tiers for a token pair"
+    )
+    parser.add_argument(
+        "--chain", required=True, help="Chain name, e.g. base / ethereum / arbitrum"
+    )
+    parser.add_argument(
+        "--token-a", required=True, help="Token symbol or address"
+    )
+    parser.add_argument(
+        "--token-b", required=True, help="Token symbol or address"
+    )
+    parser.add_argument("--rpc-url", help="RPC URL (reads from env if not provided)")
+    parser.add_argument("--output", help="Output JSON file path")
+
+    args = parser.parse_args()
+
+    try:
+        load_local_env()
+        result = compare_pools_for_pair(
+            args.chain, args.token_a, args.token_b, args.rpc_url
+        )
+        _print_comparison_table(result)
+        if args.output:
+            Path(args.output).write_text(
+                json.dumps(result, ensure_ascii=False, indent=2) + "\n",
+                encoding="utf-8",
+            )
+        dump_json(result)
+    except Exception as exc:
+        print(
+            json.dumps({"error": str(exc)}, ensure_ascii=False, indent=2),
+            file=sys.stderr,
+        )
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()