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

uniswap_autopilot/lp/v4/position.py

@@ -0,0 +1,185 @@
+#!/usr/bin/env python3
+from __future__ import annotations
+
+import argparse
+import json
+from pathlib import Path
+from typing import Any
+
+
+from uniswap_autopilot.common.common import (
+    dump_json,
+    get_v4_position_manager_address,
+    load_local_env,
+    normalize_chain,
+)
+from uniswap_autopilot.execute._internal.rpc import (
+    decode_address, decode_uint, encode_address, encode_selector,
+    encode_uint, eth_call, resolve_rpc_url,
+)
+from uniswap_autopilot.lp.v3.tick import tick_to_price
+
+
+def _parse_position_info(packed: int) -> dict[str, Any]:
+    # V4 PositionInfo packing: bits 0-23 = tickUpper, bits 24-47 = tickLower, bit 56 = hasSubscriber
+    tick_upper = packed & 0xFFFFFF
+    if tick_upper >= 0x800000:
+        tick_upper -= 0x1000000
+    tick_lower = (packed >> 24) & 0xFFFFFF
+    if tick_lower >= 0x800000:
+        tick_lower -= 0x1000000
+    has_subscriber = bool((packed >> 56) & 0x1)
+    return {"tickLower": tick_lower, "tickUpper": tick_upper, "hasSubscriber": has_subscriber}
+
+
+def query_v4_position(
+    token_id: int,
+    chain_name: str,
+    rpc_url: str | None = None,
+) -> dict[str, Any]:
+    chain = normalize_chain(chain_name)
+    rpc, _ = resolve_rpc_url(rpc_url, chain.chain_id)
+    if not rpc:
+        raise RuntimeError(f"RPC URL not configured for {chain_name}")
+
+    pm = get_v4_position_manager_address(chain_name)
+
+    # getPositionLiquidity(uint256)
+    liq_sel = encode_selector("getPositionLiquidity(uint256)")
+    liq_data = liq_sel + encode_uint(token_id).replace("0x", "")
+    raw_liq = eth_call(pm, liq_data, rpc)
+    liquidity = decode_uint(raw_liq)
+
+    # getPoolAndPositionInfo(uint256) returns (address,address,address,address,uint24,uint256,uint256)
+    info_sel = encode_selector("getPoolAndPositionInfo(uint256)")
+    info_data = info_sel + encode_uint(token_id).replace("0x", "")
+    raw_info = eth_call(pm, info_data, rpc)
+    clean = raw_info.replace("0x", "")
+
+    currency0 = decode_address("0x" + clean[0:64])
+    currency1 = decode_address("0x" + clean[64:128])
+    hooks = decode_address("0x" + clean[128:192])
+    pool_manager = decode_address("0x" + clean[192:256])
+    fee = decode_uint("0x" + clean[256:320])
+    parameters = decode_uint("0x" + clean[320:384])
+    position_info_packed = decode_uint("0x" + clean[384:448])
+    tick_spacing = parameters >> 24
+
+    pos_info = _parse_position_info(position_info_packed)
+
+    from uniswap_autopilot.common.common import resolve_token
+    try:
+        tok0 = resolve_token(chain, currency0, rpc)
+        decimals0 = tok0["decimals"]
+        symbol0 = tok0.get("symbol", currency0)
+    except Exception:
+        decimals0 = 18
+        symbol0 = currency0[:10]
+    try:
+        tok1 = resolve_token(chain, currency1, rpc)
+        decimals1 = tok1["decimals"]
+        symbol1 = tok1.get("symbol", currency1)
+    except Exception:
+        decimals1 = 18
+        symbol1 = currency1[:10]
+
+    current_tick = None
+    try:
+        from uniswap_autopilot.lp.v4.pool import compute_pool_id, query_v4_slot0
+        from uniswap_autopilot.common.common import get_v4_state_view_address
+        state_view = get_v4_state_view_address(chain_name)
+        pool_id = compute_pool_id(currency0, currency1, hooks, pool_manager, fee, tick_spacing)
+        slot0 = query_v4_slot0(state_view, pool_id, rpc)
+        current_tick = slot0["tick"]
+    except Exception:
+        pass
+
+    current_price = tick_to_price(current_tick, decimals0, decimals1) if current_tick is not None else None
+    in_range = pos_info["tickLower"] < current_tick < pos_info["tickUpper"] if current_tick is not None else None
+
+    return {
+        "action": "v4_position",
+        "chain": {"key": chain.key, "chainId": chain.chain_id},
+        "tokenId": token_id,
+        "currency0": {"address": currency0, "symbol": symbol0, "decimals": decimals0},
+        "currency1": {"address": currency1, "symbol": symbol1, "decimals": decimals1},
+        "fee": fee,
+        "tickSpacing": tick_spacing,
+        "hooks": hooks,
+        "tickLower": pos_info["tickLower"],
+        "tickUpper": pos_info["tickUpper"],
+        "liquidity": str(liquidity),
+        "currentTick": current_tick,
+        "currentPrice": current_price,
+        "inRange": in_range,
+    }
+
+
+def query_v4_positions_by_owner(
+    owner: str,
+    chain_name: str,
+    rpc_url: str | None = None,
+) -> list[int]:
+    chain = normalize_chain(chain_name)
+    rpc, _ = resolve_rpc_url(rpc_url, chain.chain_id)
+    if not rpc:
+        raise RuntimeError(f"RPC URL not configured for {chain_name}")
+
+    pm = get_v4_position_manager_address(chain_name)
+
+    bal_sel = encode_selector("balanceOf(address)")
+    bal_data = bal_sel + encode_address(owner).replace("0x", "")
+    raw_bal = eth_call(pm, bal_data, rpc)
+    count = decode_uint(raw_bal)
+
+    token_ids: list[int] = []
+    tobi_sel = encode_selector("tokenOfOwnerByIndex(address,uint256)")
+    for i in range(count):
+        data = tobi_sel + encode_address(owner).replace("0x", "") + encode_uint(i).replace("0x", "")
+        raw_tid = eth_call(pm, data, rpc)
+        token_ids.append(decode_uint(raw_tid))
+    return token_ids
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description="Uniswap V4 position queries")
+    sub = parser.add_subparsers(dest="command")
+
+    i = sub.add_parser("info", help="Query V4 position by token ID")
+    i.add_argument("--chain", required=True)
+    i.add_argument("--token-id", type=int, required=True)
+    i.add_argument("--rpc-url")
+    i.add_argument("--output")
+
+    o = sub.add_parser("owner", help="List V4 position token IDs by owner")
+    o.add_argument("--chain", required=True)
+    o.add_argument("--owner", required=True)
+    o.add_argument("--rpc-url")
+    o.add_argument("--output")
+
+    args = parser.parse_args()
+    load_local_env()
+
+    if args.command == "info":
+        result = query_v4_position(args.token_id, args.chain, args.rpc_url)
+        t0 = result["currency0"]["symbol"]
+        t1 = result["currency1"]["symbol"]
+        ir = "in-range" if result.get("inRange") else "out-of-range" if result.get("inRange") is False else "?"
+        print(f"V4 Position #{args.token_id}: {t0}/{t1} fee={result['fee']} {ir}")
+        print(f"  Range: [{result['tickLower']}, {result['tickUpper']}]  Liquidity: {result['liquidity']}")
+        if args.output:
+            Path(args.output).write_text(json.dumps(result, ensure_ascii=False, indent=2) + "\n", encoding="utf-8")
+        dump_json(result)
+    elif args.command == "owner":
+        chain = normalize_chain(args.chain)
+        token_ids = query_v4_positions_by_owner(args.owner, args.chain, args.rpc_url)
+        print(f"Found {len(token_ids)} V4 positions for {args.owner} on {chain.key}")
+        for tid in token_ids:
+            print(f"  #{tid}")
+        dump_json({"action": "v4_positions_by_owner", "chain": chain.key, "owner": args.owner, "tokenIds": token_ids})
+    else:
+        parser.print_help()
+
+
+if __name__ == "__main__":
+    main()

uniswap_autopilot/policy.py

@@ -0,0 +1,371 @@
+"""Risk-control policy engine — declarative rules, state-machine integration.
+
+A ``policy.yaml`` (or JSON) file defines per-project risk limits.  The engine
+loads the file, validates a trade *context* dict against the rules, and returns
+a ``CheckResult`` indicating whether the trade should proceed, be warned about,
+or be rejected outright.
+
+Designed to sit between the ``PREFLIGHT`` and ``SIGNED`` states in the trade
+execution state machine:
+
+    PREFLIGHT  →  policy.check()  →  pass   →  transition(SIGNED)
+                                  →  reject →  transition(FAILED)
+
+Policy file resolution (first match wins):
+
+    1. Explicit *path* argument to ``load_policy()``
+    2. ``POLICY_FILE`` environment variable
+    3. ``~/.stageforge/policy.yaml``
+    4. ``~/.stageforge/policy.json``
+
+Minimal policy file example (YAML):
+
+    global:
+      max_amount: 1000         # USD equivalent
+      allowed_chains:
+        - ethereum
+        - polygon
+        - base
+      blacklist_addresses: []
+      whitelist_addresses: []  # empty = allow all
+
+    evm-wallet-scanner:
+      max_amount: 500
+
+Rules cascade: project-specific overrides merge on top of ``global``.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+from dataclasses import dataclass, field
+from decimal import Decimal, InvalidOperation
+from pathlib import Path
+from typing import Any
+
+try:
+    import yaml as _yaml  # type: ignore[import-untyped]
+except ImportError:  # pragma: no cover
+    _yaml = None  # YAML optional; JSON always works
+
+_DEFAULT_PROJECT = __name__.split(".")[0].replace("_", "-")
+
+
+# ── Data structures ──────────────────────────────────────────────────────────
+
+
+@dataclass(frozen=True)
+class Violation:
+    """A single rule violation or warning."""
+
+    rule: str
+    message: str
+    severity: str = "reject"  # "reject" | "warn"
+
+
+@dataclass
+class CheckResult:
+    """Outcome of ``check()``."""
+
+    allowed: bool = True
+    violations: list[Violation] = field(default_factory=list)
+    warnings: list[Violation] = field(default_factory=list)
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "allowed": self.allowed,
+            "violations": [{"rule": v.rule, "message": v.message} for v in self.violations],
+            "warnings": [{"rule": w.rule, "message": w.message} for w in self.warnings],
+        }
+
+
+@dataclass
+class Policy:
+    """Resolved rules for a single project (global + project overlay)."""
+
+    max_amount: Decimal | None = None
+    allowed_chains: list[str] | None = None
+    blacklist_addresses: list[str] = field(default_factory=list)
+    whitelist_addresses: list[str] = field(default_factory=list)
+    max_slippage_bps: int | None = None
+    max_gas_price_gwei: Decimal | None = None
+    extra: dict[str, Any] = field(default_factory=dict)
+
+
+# ── Loading ──────────────────────────────────────────────────────────────────
+
+
+def _find_policy_file(explicit: str | None = None) -> Path | None:
+    """Resolve the policy file path (first match wins)."""
+    if explicit:
+        p = Path(explicit)
+        if p.is_file():
+            return p
+        return None
+
+    env = (os.environ.get("POLICY_FILE") or "").strip()
+    if env:
+        p = Path(env)
+        if p.is_file():
+            return p
+        return None
+
+    base = Path.home() / ".stageforge"
+    for name in ("policy.yaml", "policy.yml", "policy.json"):
+        p = base / name
+        if p.is_file():
+            return p
+    return None
+
+
+def _parse_file(path: Path) -> dict[str, Any]:
+    """Read a YAML or JSON policy file and return a raw dict."""
+    text = path.read_text(encoding="utf-8")
+    if path.suffix in (".yaml", ".yml"):
+        if _yaml is None:
+            raise ImportError(
+                "PyYAML is required to load .yaml policy files. "
+                "Install it with: pip install pyyaml"
+            )
+        return _yaml.safe_load(text) or {}  # type: ignore[no-any-return]
+    return json.loads(text)
+
+
+def _decimal_or_none(val: Any) -> Decimal | None:
+    if val is None:
+        return None
+    try:
+        return Decimal(str(val))
+    except (InvalidOperation, ValueError):
+        return None
+
+
+def _build_policy(raw: dict[str, Any]) -> Policy:
+    """Build a ``Policy`` from a raw rule dict (global or project section)."""
+    known_keys = {
+        "max_amount", "allowed_chains", "blacklist_addresses",
+        "whitelist_addresses", "max_slippage_bps", "max_gas_price_gwei",
+    }
+    extra = {k: v for k, v in raw.items() if k not in known_keys}
+
+    bl = raw.get("blacklist_addresses") or []
+    wl = raw.get("whitelist_addresses") or []
+
+    return Policy(
+        max_amount=_decimal_or_none(raw.get("max_amount")),
+        allowed_chains=raw.get("allowed_chains"),
+        blacklist_addresses=[a.lower() for a in bl],
+        whitelist_addresses=[a.lower() for a in wl],
+        max_slippage_bps=raw.get("max_slippage_bps"),
+        max_gas_price_gwei=_decimal_or_none(raw.get("max_gas_price_gwei")),
+        extra=extra,
+    )
+
+
+def _merge(base: dict[str, Any], overlay: dict[str, Any]) -> dict[str, Any]:
+    """Shallow merge *overlay* on top of *base* (overlay wins for non-None)."""
+    merged = dict(base)
+    for k, v in overlay.items():
+        if v is not None:
+            merged[k] = v
+    return merged
+
+
+def load_policy(
+    path: str | None = None,
+    *,
+    project: str = _DEFAULT_PROJECT,
+) -> Policy:
+    """Load and resolve the policy for *project*.
+
+    Returns a ``Policy`` with ``global`` rules as base and project-specific
+    overrides applied on top.  If no policy file is found, returns a
+    permissive default (no limits).
+    """
+    fp = _find_policy_file(path)
+    if fp is None:
+        return Policy()
+
+    raw = _parse_file(fp)
+    global_rules: dict[str, Any] = raw.get("global", {})
+    project_rules: dict[str, Any] = raw.get(project, {})
+
+    merged = _merge(global_rules, project_rules)
+    return _build_policy(merged)
+
+
+# ── Checks ───────────────────────────────────────────────────────────────────
+
+
+def check(
+    policy: Policy,
+    context: dict[str, Any],
+) -> CheckResult:
+    """Validate a trade *context* against *policy* rules.
+
+    Expected *context* keys (all optional — absent keys skip the check):
+
+        amount          float/str/Decimal — trade amount (USD or native units)
+        chain           str — chain name, e.g. "ethereum"
+        sender          str — sender address
+        receiver        str — receiver address
+        spender         str — spender / operator address
+        slippage_bps    int — slippage in basis points
+        gas_price_gwei  float/str — gas price in gwei
+
+    Returns a ``CheckResult`` with ``allowed=False`` if any hard violation is
+    found.  Warnings do not block the trade.
+    """
+    result = CheckResult()
+
+    _check_max_amount(policy, context, result)
+    _check_allowed_chains(policy, context, result)
+    _check_blacklist(policy, context, result)
+    _check_whitelist(policy, context, result)
+    _check_max_slippage(policy, context, result)
+    _check_max_gas_price(policy, context, result)
+
+    if result.violations:
+        result.allowed = False
+
+    return result
+
+
+# ── Individual rule checks ───────────────────────────────────────────────────
+
+
+def _check_max_amount(policy: Policy, ctx: dict[str, Any], res: CheckResult) -> None:
+    if policy.max_amount is None:
+        return
+    raw = ctx.get("amount")
+    if raw is None:
+        return
+    try:
+        amt = Decimal(str(raw))
+    except (InvalidOperation, ValueError):
+        return
+    if amt > policy.max_amount:
+        res.violations.append(Violation(
+            rule="max_amount",
+            message=f"amount {amt} exceeds limit {policy.max_amount}",
+        ))
+
+
+def _check_allowed_chains(policy: Policy, ctx: dict[str, Any], res: CheckResult) -> None:
+    if not policy.allowed_chains:
+        return
+    chain = ctx.get("chain")
+    if chain is None:
+        return
+    if chain.lower() not in [c.lower() for c in policy.allowed_chains]:
+        res.violations.append(Violation(
+            rule="allowed_chains",
+            message=f"chain {chain!r} not in allowed list {policy.allowed_chains}",
+        ))
+
+
+def _check_blacklist(policy: Policy, ctx: dict[str, Any], res: CheckResult) -> None:
+    if not policy.blacklist_addresses:
+        return
+    for key in ("sender", "receiver", "spender"):
+        addr = ctx.get(key)
+        if addr and addr.lower() in policy.blacklist_addresses:
+            res.violations.append(Violation(
+                rule="blacklist_addresses",
+                message=f"{key} {addr} is blacklisted",
+            ))
+
+
+def _check_whitelist(policy: Policy, ctx: dict[str, Any], res: CheckResult) -> None:
+    if not policy.whitelist_addresses:
+        return
+    for key in ("sender", "receiver", "spender"):
+        addr = ctx.get(key)
+        if addr and addr.lower() not in policy.whitelist_addresses:
+            res.warnings.append(Violation(
+                rule="whitelist_addresses",
+                message=f"{key} {addr} not in whitelist",
+                severity="warn",
+            ))
+
+
+def _check_max_slippage(policy: Policy, ctx: dict[str, Any], res: CheckResult) -> None:
+    if policy.max_slippage_bps is None:
+        return
+    slippage = ctx.get("slippage_bps")
+    if slippage is None:
+        return
+    try:
+        val = int(slippage)
+    except (TypeError, ValueError):
+        return
+    if val > policy.max_slippage_bps:
+        res.violations.append(Violation(
+            rule="max_slippage_bps",
+            message=f"slippage {val} bps exceeds limit {policy.max_slippage_bps} bps",
+        ))
+
+
+def _check_max_gas_price(policy: Policy, ctx: dict[str, Any], res: CheckResult) -> None:
+    if policy.max_gas_price_gwei is None:
+        return
+    gp = ctx.get("gas_price_gwei")
+    if gp is None:
+        return
+    try:
+        val = Decimal(str(gp))
+    except (InvalidOperation, ValueError):
+        return
+    if val > policy.max_gas_price_gwei:
+        res.warnings.append(Violation(
+            rule="max_gas_price_gwei",
+            message=f"gas price {val} gwei exceeds soft limit {policy.max_gas_price_gwei} gwei",
+            severity="warn",
+        ))
+
+
+# ── Uniswap-specific checks ──────────────────────────────────────────────────
+
+
+def _check_min_output_amount(policy: Policy, ctx: dict[str, Any], res: CheckResult) -> None:
+    min_out = policy.extra.get("min_output_amount")
+    if min_out is None:
+        return
+    output = ctx.get("output_amount")
+    if output is None:
+        return
+    try:
+        out_dec = Decimal(str(output))
+        min_dec = Decimal(str(min_out))
+    except (InvalidOperation, ValueError):
+        return
+    if min_dec <= 0:
+        return  # 0 or negative means disabled
+    if out_dec < min_dec:
+        res.violations.append(Violation(
+            rule="min_output_amount",
+            message=f"output amount {out_dec} below minimum {min_dec}",
+        ))
+
+
+def check_uniswap(
+    policy: Policy,
+    context: dict[str, Any],
+) -> CheckResult:
+    """Run shared + Uniswap-specific checks."""
+    result = check(policy, context)
+    _check_min_output_amount(policy, context, result)
+    if result.violations:
+        result.allowed = False
+    return result
+
+
+__all__ = [
+    "CheckResult",
+    "Policy",
+    "Violation",
+    "check",
+    "check_uniswap",
+    "load_policy",
+]

uniswap_autopilot/price_feed.py

@@ -0,0 +1,100 @@
+"""Price feed — multi-source token price lookup via CoinGecko free API.
+
+Provides:
+- ``get_price(chain, address, tier)`` — single token price
+- ``get_prices_batch(pairs, tier)`` — batch price lookup
+- ``get_eth_price()`` — current ETH/USD price
+
+All functions are designed as drop-in replacements for the price_feed module
+expected by ``analytics/position.py``, ``execute/_internal/tx.py``, and ``search/risk.py``.
+"""
+
+from __future__ import annotations
+
+import json
+import urllib.request
+from typing import Any
+from urllib.error import HTTPError, URLError
+
+# ---------------------------------------------------------------------------
+# Chain name → CoinGecko platform id map
+# ---------------------------------------------------------------------------
+CHAIN_TO_PLATFORM: dict[str, str] = {
+    "ethereum": "ethereum",
+    "base": "base",
+    "arbitrum": "arbitrum-one",
+    "optimism": "optimistic-ethereum",
+    "polygon": "polygon-pos",
+    "bsc": "binance-smart-chain",
+    "avalanche": "avalanche",
+    "celo": "celo",
+    "world_chain": "world-chain",
+    "soneium": "soneium",
+    "linea": "linea",
+    "blast": "blast",
+    "zora": "zora",
+    "unichain": "unichain",
+}
+
+COINGECKO_API = "https://api.coingecko.com/api/v3"
+
+
+# ---------------------------------------------------------------------------
+# Internal helpers
+# ---------------------------------------------------------------------------
+
+def _fetch(url: str, timeout: int = 15) -> Any:
+    """GET a JSON endpoint with retry logic."""
+    req = urllib.request.Request(url, headers={"Accept": "application/json", "User-Agent": "uniswap-autopilot/1.0"})
+    try:
+        with urllib.request.urlopen(req, timeout=timeout) as resp:
+            return json.loads(resp.read())
+    except (HTTPError, URLError, json.JSONDecodeError):
+        return None
+
+
+# ---------------------------------------------------------------------------
+# Public API
+# ---------------------------------------------------------------------------
+
+def get_price(chain: str, address: str, tier: str = "normal") -> dict[str, Any] | None:
+    """Get current USD price for a single token.
+
+    Returns ``{"price": float, "symbol": str, ...}`` or ``None`` on failure.
+    """
+    platform = CHAIN_TO_PLATFORM.get(chain.lower())
+    if not platform:
+        return None
+
+    url = f"{COINGECKO_API}/simple/token_price/{platform}?contract_addresses={address}&vs_currencies=usd"
+    data = _fetch(url)
+    if not data or address.lower() not in data:
+        return None
+
+    price = data[address.lower()].get("usd")
+    if price is None:
+        return None
+
+    return {"price": float(price), "symbol": "", "source": "coingecko"}
+
+
+def get_prices_batch(pairs: list[tuple[str, str]], tier: str = "normal") -> dict[str, dict[str, Any]]:
+    """Batch fetch prices for multiple (chain, address) pairs.
+
+    Returns ``{"chain:address": {"price": float}, ...}``.
+    """
+    results: dict[str, dict[str, Any]] = {}
+    for chain, address in pairs:
+        price_data = get_price(chain, address, tier)
+        if price_data:
+            results[f"{chain}:{address.lower()}"] = price_data
+    return results
+
+
+def get_eth_price() -> float | None:
+    """Get current ETH/USD price."""
+    url = f"{COINGECKO_API}/simple/price?ids=ethereum&vs_currencies=usd"
+    data = _fetch(url)
+    if not data:
+        return None
+    return float(data.get("ethereum", {}).get("usd", 0)) or None