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

uniswap_autopilot/lp/v2/positions.py

@@ -0,0 +1,177 @@
+#!/usr/bin/env python3
+from __future__ import annotations
+
+import argparse
+import sys
+from decimal import Decimal
+from typing import Any
+
+
+from uniswap_autopilot.common.common import (
+    dump_json,
+    get_v2_factory_address,
+    load_local_env,
+    normalize_chain,
+    resolve_token,
+    resolve_wallet_address,
+    sort_token_addresses,
+)
+from uniswap_autopilot.execute._internal.rpc import resolve_rpc_url
+from uniswap_autopilot.lp.v2.pair import query_lp_balance, query_pair_address, query_reserves, query_total_supply
+
+V2_CHAINS = ["ethereum", "optimism", "bsc", "polygon", "arbitrum", "avalanche", "world_chain"]
+
+COMMON_PAIRS = [
+    ("WETH", "USDC"), ("WETH", "USDT"), ("WETH", "DAI"),
+    ("WBTC", "WETH"), ("WBTC", "USDC"),
+    ("UNI", "WETH"), ("LINK", "WETH"),
+    ("USDC", "USDT"),
+    ("WBNB", "USDT"), ("WBNB", "USDC"), ("WBNB", "ETH"),
+    ("WAVAX", "USDC"), ("WAVAX", "USDT"), ("WAVAX", "WETH"),
+    ("WLD", "USDC"), ("WLD", "WETH"),
+    ("OP", "WETH"), ("OP", "USDC"),
+    ("ARB", "WETH"), ("ARB", "USDC"),
+    ("CAKE", "WBNB"),
+    ("WMATIC", "USDC"), ("WMATIC", "WETH"),
+]
+
+
+def _base_unit_to_human(raw: int, decimals: int) -> str:
+    if raw == 0:
+        return "0"
+    d = Decimal(raw) / Decimal(10 ** decimals)
+    return f"{d:.6f}".rstrip("0").rstrip(".")
+
+
+def scan_v2_positions(
+    chain_name: str,
+    wallet: str | None = None,
+    rpc_url: str | None = None,
+    pairs: list[tuple[str, str]] | None = None,
+    chain_tokens: dict[str, dict] | None = None,
+) -> list[dict[str, Any]]:
+    chain = normalize_chain(chain_name)
+    wallet_addr = resolve_wallet_address(wallet)
+    if not wallet_addr:
+        raise ValueError("wallet address required")
+
+    rpc = rpc_url or resolve_rpc_url(None, chain.chain_id)[0]
+    try:
+        factory = get_v2_factory_address(chain_name)
+    except ValueError:
+        return []
+
+    scan_pairs = pairs or COMMON_PAIRS
+    token_cache: dict[str, dict] = dict(chain_tokens or {})
+
+    positions: list[dict[str, Any]] = []
+
+    for sym_a, sym_b in scan_pairs:
+        try:
+            if sym_a not in token_cache:
+                token_cache[sym_a] = resolve_token(chain, sym_a, rpc)
+            if sym_b not in token_cache:
+                token_cache[sym_b] = resolve_token(chain, sym_b, rpc)
+        except Exception:
+            continue
+
+        tok_a = token_cache[sym_a]
+        tok_b = token_cache[sym_b]
+
+        t0, t1 = sort_token_addresses(tok_a["address"], tok_b["address"])
+
+        pair_addr = query_pair_address(t0, t1, factory, rpc)
+        if not pair_addr:
+            continue
+
+        lp_bal = query_lp_balance(pair_addr, wallet_addr, rpc)
+        if lp_bal == 0:
+            continue
+
+        total_supply = query_total_supply(pair_addr, rpc)
+        reserves = query_reserves(pair_addr, rpc)
+
+        share_pct = Decimal(lp_bal) / Decimal(total_supply) * Decimal("100") if total_supply > 0 else Decimal("0")
+
+        # Determine which reserve maps to which token
+        reserve_a = reserves["reserve0"] if tok_a["address"].lower() == t0.lower() else reserves["reserve1"]
+        reserve_b = reserves["reserve1"] if tok_a["address"].lower() == t0.lower() else reserves["reserve0"]
+
+        my_a = int(Decimal(reserve_a) * Decimal(lp_bal) / Decimal(total_supply)) if total_supply > 0 else 0
+        my_b = int(Decimal(reserve_b) * Decimal(lp_bal) / Decimal(total_supply)) if total_supply > 0 else 0
+
+        positions.append({
+            "chain": chain_name,
+            "pair": f"{sym_a}/{sym_b}",
+            "pairAddress": pair_addr,
+            "lpBalance": str(lp_bal),
+            "totalSupply": str(total_supply),
+            "sharePct": f"{share_pct:.6f}",
+            "tokenA": {"symbol": sym_a, "amount": str(my_a), "human": _base_unit_to_human(my_a, tok_a["decimals"])},
+            "tokenB": {"symbol": sym_b, "amount": str(my_b), "human": _base_unit_to_human(my_b, tok_b["decimals"])},
+        })
+
+    return positions
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description="查询钱包 V2 LP 仓位")
+    parser.add_argument("--chain", default="", help="链名（--all-chains 时可省略）")
+    parser.add_argument("--wallet", help="钱包地址")
+    parser.add_argument("--rpc-url", help="RPC URL")
+    parser.add_argument("--pair", action="append", help="指定交易对，如 WETH/USDC（可多次指定）")
+    parser.add_argument("--all-chains", action="store_true", help="扫描所有 V2 链")
+    args = parser.parse_args()
+
+    load_local_env()
+
+    custom_pairs: list[tuple[str, str]] | None = None
+    if args.pair:
+        custom_pairs = []
+        for p in args.pair:
+            parts = p.split("/")
+            if len(parts) != 2:
+                print(f"invalid pair format: {p}, expected TOKEN_A/TOKEN_B", file=sys.stderr)
+                sys.exit(1)
+            custom_pairs.append((parts[0].strip(), parts[1].strip()))
+
+    if args.all_chains:
+        all_positions: list[dict[str, Any]] = []
+        for c in V2_CHAINS:
+            try:
+                positions = scan_v2_positions(c, args.wallet, args.rpc_url, custom_pairs)
+                all_positions.extend(positions)
+            except Exception as e:
+                print(f"  {c}: {e}", file=sys.stderr)
+        if not all_positions:
+            print("No V2 LP positions found on any chain.")
+        else:
+            print(f"\nV2 LP Positions ({len(all_positions)} found):")
+            print("-" * 60)
+            for pos in all_positions:
+                print(f"  {pos['chain']:12s} {pos['pair']:15s} share={pos['sharePct']}%")
+                print(f"    tokenA: {pos['tokenA']['human']} {pos['tokenA']['symbol']}")
+                print(f"    tokenB: {pos['tokenB']['human']} {pos['tokenB']['symbol']}")
+                print(f"    pair:   {pos['pairAddress']}")
+            print("-" * 60)
+        dump_json({"action": "v2_positions_all", "positions": all_positions, "count": len(all_positions)})
+    else:
+        if not args.chain:
+            parser.error("--chain is required when not using --all-chains")
+        positions = scan_v2_positions(args.chain, args.wallet, args.rpc_url, custom_pairs)
+        if not positions:
+            print(f"No V2 LP positions found on {args.chain}.")
+        else:
+            print(f"\nV2 LP Positions on {args.chain} ({len(positions)} found):")
+            print("-" * 60)
+            for pos in positions:
+                print(f"  {pos['pair']:15s} share={pos['sharePct']}%")
+                print(f"    tokenA: {pos['tokenA']['human']} {pos['tokenA']['symbol']}")
+                print(f"    tokenB: {pos['tokenB']['human']} {pos['tokenB']['symbol']}")
+                print(f"    pair:   {pos['pairAddress']}")
+            print("-" * 60)
+        dump_json({"action": "v2_positions", "chain": args.chain, "positions": positions, "count": len(positions)})
+
+
+if __name__ == "__main__":
+    main()

uniswap_autopilot/lp/v3/approve.py

@@ -0,0 +1,109 @@
+#!/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 (
+    dump_json,
+    get_position_manager_address,
+    load_local_env,
+    normalize_chain,
+    resolve_token,
+)
+from uniswap_autopilot.execute._internal.rpc import (
+    build_calldata, encode_address, encode_uint, query_erc20_allowance, resolve_rpc_url,
+)
+
+
+def check_lp_approvals(
+    token0_address: str,
+    token1_address: str,
+    owner: str,
+    chain_name: str,
+    rpc_url: str | None = None,
+) -> dict[str, Any]:
+    chain = normalize_chain(chain_name)
+    pm = get_position_manager_address(chain_name)
+    rpc, _ = resolve_rpc_url(rpc_url, chain.chain_id)
+    if not rpc:
+        raise RuntimeError(f"RPC URL not configured for {chain_name}")
+
+    allowance0 = query_erc20_allowance(token0_address, owner, pm, rpc)
+    allowance1 = query_erc20_allowance(token1_address, owner, pm, rpc)
+
+    return {
+        "action": "lp_approval_check",
+        "owner": owner,
+        "spender": pm,
+        "token0": {"address": token0_address, "allowance": str(allowance0), "needsApproval": allowance0 == 0},
+        "token1": {"address": token1_address, "allowance": str(allowance1), "needsApproval": allowance1 == 0},
+    }
+
+
+def build_approval_calldata(token: str, spender: str, amount: str = None) -> str:
+    approve_amount = amount or str(2**256 - 1)
+    return build_calldata(
+        "approve(address,uint256)",
+        encode_address(spender),
+        encode_uint(int(approve_amount)),
+    )
+
+
+def build_approval_tx(
+    token: str,
+    owner: str,
+    chain_name: str,
+    amount: str | None = None,
+) -> dict[str, Any]:
+    chain = normalize_chain(chain_name)
+    pm = get_position_manager_address(chain_name)
+    calldata = build_approval_calldata(token, pm, amount)
+    return {
+        "kind": "approval",
+        "to": token,
+        "data": calldata,
+        "value": "0",
+        "chainId": chain.chain_id,
+        "from": owner,
+    }
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description="检查/构造 LP 所需的 ERC20 approval")
+    parser.add_argument("--chain", required=True)
+    parser.add_argument("--token-a", required=True, help="代币 symbol 或地址")
+    parser.add_argument("--token-b", required=True, help="代币 symbol 或地址")
+    parser.add_argument("--owner", required=True, help="钱包地址")
+    parser.add_argument("--rpc-url")
+    parser.add_argument("--output")
+    args = parser.parse_args()
+
+    try:
+        load_local_env()
+        chain = normalize_chain(args.chain)
+        token_a = resolve_token(chain, args.token_a)
+        token_b = resolve_token(chain, args.token_b)
+        from uniswap_autopilot.common.common import sort_token_addresses
+        t0, t1 = sort_token_addresses(token_a["address"], token_b["address"])
+        result = check_lp_approvals(t0, t1, args.owner, args.chain, args.rpc_url)
+
+        if result["token0"]["needsApproval"]:
+            result["token0"]["approvalTx"] = build_approval_tx(t0, args.owner, args.chain)
+        if result["token1"]["needsApproval"]:
+            result["token1"]["approvalTx"] = build_approval_tx(t1, args.owner, args.chain)
+
+        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()

uniswap_autopilot/lp/v3/auto_rebalance.py

@@ -0,0 +1,282 @@
+#!/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, load_local_env, normalize_chain, resolve_wallet_address, resolve_token, decimal_to_base_units
+from uniswap_autopilot.lp.v3.position import query_position
+from uniswap_autopilot.analytics.position import analyze_position, analyze_positions_by_owner
+from uniswap_autopilot.analytics.range_suggest import suggest_ranges
+from uniswap_autopilot.lp.v3.build_tx import (
+    build_decrease_liquidity_transaction,
+    build_collect_transaction,
+    build_mint_transaction,
+)
+
+REBALANCE_PROFILES = {"CONSERVATIVE", "MODERATE", "AGGRESSIVE"}
+
+
+def scan_rebalance_candidates(
+    chain_name: str,
+    wallet: str,
+    rpc_url: str | None = None,
+) -> dict[str, Any]:
+    chain = normalize_chain(chain_name)
+    analysis = analyze_positions_by_owner(chain_name, wallet, rpc_url)
+
+    candidates: list[dict[str, Any]] = []
+    in_range: list[dict[str, Any]] = []
+
+    for pos in analysis.get("positions", []):
+        entry = {
+            "tokenId": pos.get("tokenId"),
+            "token0": pos.get("token0", {}).get("symbol", "?"),
+            "token1": pos.get("token1", {}).get("symbol", "?"),
+            "feeTier": pos.get("feeTier"),
+            "inRange": pos.get("inRange"),
+            "tickLower": pos.get("tickLower"),
+            "tickUpper": pos.get("tickUpper"),
+            "totalValueUsd": pos.get("totalValueUsd", 0.0),
+            "uncollectedFeesUsd": pos.get("uncollectedFees", {}).get("totalUsd", 0.0),
+        }
+        if not pos.get("inRange", True):
+            candidates.append(entry)
+        else:
+            in_range.append(entry)
+
+    return {
+        "action": "rebalance_scan",
+        "chain": {"key": chain.key, "chainId": chain.chain_id},
+        "wallet": wallet,
+        "totalPositions": len(analysis.get("positions", [])),
+        "outOfRange": candidates,
+        "inRange": in_range,
+        "candidatesForRebalance": [c["tokenId"] for c in candidates],
+    }
+
+
+def execute_rebalance(
+    chain_name: str,
+    token_id: int,
+    profile: str = "MODERATE",
+    slippage_pct: float = 0.5,
+    wallet: str | None = None,
+    rpc_url: str | None = None,
+    request_only: bool = True,
+) -> dict[str, Any]:
+    chain = normalize_chain(chain_name)
+    owner = resolve_wallet_address(wallet) or ""
+    if not owner:
+        raise ValueError("wallet address required")
+
+    profile = profile.upper()
+    if profile not in REBALANCE_PROFILES:
+        raise ValueError(f"profile must be one of {REBALANCE_PROFILES}, got '{profile}'")
+
+    # Step 1: query current position
+    pos = query_position(token_id, chain_name, rpc_url)
+    tick_lower = pos["tickLower"]
+    tick_upper = pos["tickUpper"]
+    fee_tier = pos["fee"]
+    tok0_addr = pos["token0"]
+    tok1_addr = pos["token1"]
+    current_liq = int(pos["liquidity"])
+    if current_liq == 0:
+        raise ValueError(f"position {token_id} has no liquidity")
+
+    # Get analyzed position for human-readable amounts + fees
+    analyzed = analyze_position(chain_name, token_id, rpc_url)
+    tok0_amount_human = float(analyzed["token0"]["amount"])
+    tok1_amount_human = float(analyzed["token1"]["amount"])
+    fee0_human = float(analyzed["uncollectedFees"]["token0"] or "0")
+    fee1_human = float(analyzed["uncollectedFees"]["token1"] or "0")
+
+    # Step 2: get suggested ranges
+    ranges = suggest_ranges(chain_name, tok0_addr, tok1_addr, fee_tier, rpc_url)
+    suggestions = ranges.get("suggestions", [])
+    target = None
+    for s in suggestions:
+        if s["profile"] == profile:
+            target = s
+            break
+    if not target:
+        raise ValueError(f"profile '{profile}' not found in range suggestions")
+
+    new_tick_lower = target["tickLower"]
+    new_tick_upper = target["tickUpper"]
+
+    # Step 3: decrease 100%
+    decrease_result = build_decrease_liquidity_transaction(
+        chain_name=chain_name,
+        token_id=token_id,
+        liquidity_pct=100.0,
+        slippage_pct=slippage_pct,
+        wallet=owner,
+        rpc_url=rpc_url,
+    )
+
+    # Step 4: collect all
+    collect_result = build_collect_transaction(
+        chain_name=chain_name,
+        token_id=token_id,
+        recipient=owner,
+    )
+
+    # Step 5: mint new position with suggested range
+    # Convert human amounts + fees to base units for the mint
+    from decimal import Decimal as D
+    tok0_info = resolve_token(chain, tok0_addr)
+    tok1_info = resolve_token(chain, tok1_addr)
+    total0 = D(str(tok0_amount_human)) + D(str(fee0_human))
+    total1 = D(str(tok1_amount_human)) + D(str(fee1_human))
+    amount0 = decimal_to_base_units(total0, tok0_info["decimals"])
+    amount1 = decimal_to_base_units(total1, tok1_info["decimals"])
+
+    mint_result = build_mint_transaction(
+        chain_name=chain_name,
+        token_a=tok0_addr,
+        token_b=tok1_addr,
+        fee_tier=fee_tier,
+        tick_lower=new_tick_lower,
+        tick_upper=new_tick_upper,
+        amount0=amount0,
+        amount1=amount1,
+        slippage_pct=slippage_pct,
+        wallet=owner,
+        rpc_url=rpc_url,
+        request_only=request_only,
+    )
+
+    return {
+        "action": "rebalance",
+        "chain": {"key": chain.key, "chainId": chain.chain_id},
+        "tokenId": token_id,
+        "profile": profile,
+        "feeTier": fee_tier,
+        "oldRange": {"tickLower": tick_lower, "tickUpper": tick_upper},
+        "newRange": {"tickLower": new_tick_lower, "tickUpper": new_tick_upper},
+        "newRangeWidthPct": target.get("rangeWidthPct"),
+        "currentLiquidity": str(current_liq),
+        "steps": {
+            "decrease": decrease_result,
+            "collect": collect_result,
+            "mint": mint_result,
+        },
+        "broadcastReady": not request_only,
+    }
+
+
+def batch_rebalance(
+    chain_name: str,
+    wallet: str,
+    profile: str = "MODERATE",
+    slippage_pct: float = 0.5,
+    rpc_url: str | None = None,
+    request_only: bool = True,
+) -> dict[str, Any]:
+    chain = normalize_chain(chain_name)
+    scan = scan_rebalance_candidates(chain_name, wallet, rpc_url)
+    candidates = scan["candidatesForRebalance"]
+
+    succeeded: list[int] = []
+    failed: list[dict[str, Any]] = []
+    results: list[dict[str, Any]] = []
+
+    for tid in candidates:
+        try:
+            result = execute_rebalance(
+                chain_name=chain_name,
+                token_id=tid,
+                profile=profile,
+                slippage_pct=slippage_pct,
+                wallet=wallet,
+                rpc_url=rpc_url,
+                request_only=request_only,
+            )
+            succeeded.append(tid)
+            results.append({
+                "tokenId": tid,
+                "status": "success",
+                "newRange": result["newRange"],
+                "steps": result["steps"],
+            })
+        except Exception as exc:
+            failed.append({"tokenId": tid, "error": str(exc)})
+            results.append({"tokenId": tid, "status": "error", "error": str(exc)})
+
+    return {
+        "action": "batch_rebalance",
+        "chain": {"key": chain.key, "chainId": chain.chain_id},
+        "wallet": wallet,
+        "profile": profile,
+        "totalAttempted": len(candidates),
+        "succeeded": succeeded,
+        "failed": failed,
+        "results": results,
+    }
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description="V3 LP auto-rebalance: close out-of-range and open new range")
+    sub = parser.add_subparsers(dest="command")
+
+    s = sub.add_parser("scan", help="Find out-of-range positions eligible for rebalance")
+    s.add_argument("--chain", required=True)
+    s.add_argument("--wallet", required=True)
+    s.add_argument("--rpc-url")
+    s.add_argument("--output")
+
+    e = sub.add_parser("execute", help="Execute rebalance: decrease + collect + mint with new range")
+    e.add_argument("--chain", required=True)
+    e.add_argument("--token-id", type=int, required=True)
+    e.add_argument("--profile", choices=["CONSERVATIVE", "MODERATE", "AGGRESSIVE"], default="MODERATE")
+    e.add_argument("--wallet")
+    e.add_argument("--slippage", type=float, default=0.5)
+    e.add_argument("--rpc-url")
+    e.add_argument("--output")
+
+    b = sub.add_parser("batch", help="Batch rebalance all out-of-range positions")
+    b.add_argument("--chain", required=True)
+    b.add_argument("--wallet", required=True)
+    b.add_argument("--profile", choices=["CONSERVATIVE", "MODERATE", "AGGRESSIVE"], default="MODERATE")
+    b.add_argument("--slippage", type=float, default=0.5)
+    b.add_argument("--rpc-url")
+    b.add_argument("--output")
+
+    args = parser.parse_args()
+    load_local_env()
+
+    if args.command == "scan":
+        result = scan_rebalance_candidates(args.chain, args.wallet, args.rpc_url)
+        n = len(result["candidatesForRebalance"])
+        print(f"Found {n}/{result['totalPositions']} out-of-range positions eligible for rebalance")
+        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 == "execute":
+        result = execute_rebalance(
+            args.chain, args.token_id, args.profile, args.slippage,
+            args.wallet, args.rpc_url,
+        )
+        print(f"Rebalance plan for position #{args.token_id}: decrease -> collect -> mint ({args.profile})")
+        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 == "batch":
+        result = batch_rebalance(
+            args.chain, args.wallet, args.profile, args.slippage, args.rpc_url,
+        )
+        print(f"Batch rebalance: {len(result['succeeded'])} succeeded, {len(result['failed'])} failed / {result['totalAttempted']} attempted")
+        if args.output:
+            Path(args.output).write_text(json.dumps(result, ensure_ascii=False, indent=2) + "\n", encoding="utf-8")
+        dump_json(result)
+    else:
+        parser.print_help()
+
+
+if __name__ == "__main__":
+    main()