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

uniswap_autopilot/common/approval_cleanup.py

@@ -0,0 +1,255 @@
+#!/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_permit2_address,
+    get_position_manager_address,
+    get_universal_router_address,
+    get_v2_router02_address,
+    load_local_env,
+    normalize_chain,
+    resolve_token,
+    resolve_wallet_address,
+)
+from uniswap_autopilot.execute._internal.rpc import (
+    build_calldata, encode_address, encode_uint, query_erc20_allowance, resolve_rpc_url,
+)
+
+UINT256_MAX = "115792089237316195423570985008687907853269984665640564039457584007913129639935"
+
+
+def _get_spenders(chain_name: str) -> list[dict[str, str]]:
+    spenders: list[dict[str, str]] = []
+    try:
+        spenders.append({"label": "positionManager", "address": get_position_manager_address(chain_name)})
+    except ValueError:
+        pass
+    try:
+        spenders.append({"label": "router02", "address": get_v2_router02_address(chain_name)})
+    except ValueError:
+        pass
+    spenders.append({"label": "permit2", "address": get_permit2_address()})
+    ur = get_universal_router_address(chain_name)
+    if ur:
+        spenders.append({"label": "universalRouter", "address": ur})
+    return spenders
+
+
+def _get_token_list(chain_name: str) -> list[dict[str, Any]]:
+    chain = normalize_chain(chain_name)
+    tokens: list[dict[str, Any]] = []
+    seen: set[str] = set()
+    for sym, tok in chain.tokens.items():
+        addr = tok.address
+        if addr == "NATIVE" or addr.lower() in seen:
+            continue
+        seen.add(addr.lower())
+        tokens.append({"symbol": sym, "address": addr, "decimals": tok.decimals})
+    return tokens
+
+
+def scan_approvals(
+    chain_name: str,
+    wallet: 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}")
+
+    spenders = _get_spenders(chain_name)
+    tokens = _get_token_list(chain_name)
+
+    approvals: list[dict[str, Any]] = []
+    for tok in tokens:
+        for sp in spenders:
+            try:
+                allowance = query_erc20_allowance(tok["address"], wallet, sp["address"], rpc)
+            except Exception:
+                continue
+            if allowance == 0:
+                continue
+            approvals.append({
+                "token": tok["symbol"],
+                "tokenAddress": tok["address"],
+                "spenderLabel": sp["label"],
+                "spenderAddress": sp["address"],
+                "allowance": str(allowance),
+                "isMaxApproval": str(allowance) == UINT256_MAX,
+            })
+
+    return {
+        "action": "approval_scan",
+        "chain": {"key": chain.key, "chainId": chain.chain_id},
+        "wallet": wallet,
+        "spendersChecked": len(spenders),
+        "tokensChecked": len(tokens),
+        "nonZeroApprovals": len(approvals),
+        "approvals": approvals,
+    }
+
+
+def _build_revoke_tx(
+    token_address: str,
+    spender_address: str,
+    wallet: str,
+    chain_id: int,
+) -> dict[str, Any]:
+    calldata = build_calldata(
+        "approve(address,uint256)",
+        encode_address(spender_address),
+        encode_uint(0),
+    )
+    return {
+        "kind": "approval_revoke",
+        "to": token_address,
+        "data": calldata,
+        "value": "0",
+        "chainId": chain_id,
+        "from": wallet,
+    }
+
+
+def revoke_approval(
+    chain_name: str,
+    wallet: str,
+    token: str,
+    spender: str,
+    rpc_url: str | None = None,
+) -> dict[str, Any]:
+    chain = normalize_chain(chain_name)
+    resolved_wallet = resolve_wallet_address(wallet) or wallet
+
+    tok = resolve_token(chain, token)
+    if tok["address"] == "NATIVE":
+        raise ValueError("cannot revoke approval for native token")
+
+    spenders = _get_spenders(chain_name)
+    target = None
+    for sp in spenders:
+        if sp["label"].lower() == spender.lower() or sp["address"].lower() == spender.lower():
+            target = sp
+            break
+    if not target:
+        available = [sp["label"] for sp in spenders]
+        raise ValueError(f"spender '{spender}' not found. Available: {available}")
+
+    tx = _build_revoke_tx(tok["address"], target["address"], resolved_wallet, chain.chain_id)
+
+    return {
+        "action": "approval_revoke",
+        "chain": {"key": chain.key, "chainId": chain.chain_id},
+        "wallet": resolved_wallet,
+        "token": tok["symbol"],
+        "tokenAddress": tok["address"],
+        "spenderLabel": target["label"],
+        "spenderAddress": target["address"],
+        "transaction": tx,
+    }
+
+
+def revoke_all(
+    chain_name: str,
+    wallet: str,
+    rpc_url: str | None = None,
+    dry_run: bool = True,
+) -> dict[str, Any]:
+    chain = normalize_chain(chain_name)
+    resolved_wallet = resolve_wallet_address(wallet) or wallet
+
+    scan = scan_approvals(chain_name, resolved_wallet, rpc_url)
+
+    revoke_txs: list[dict[str, Any]] = []
+    for approval in scan["approvals"]:
+        tx = _build_revoke_tx(
+            approval["tokenAddress"],
+            approval["spenderAddress"],
+            resolved_wallet,
+            chain.chain_id,
+        )
+        revoke_txs.append({
+            "token": approval["token"],
+            "tokenAddress": approval["tokenAddress"],
+            "spenderLabel": approval["spenderLabel"],
+            "spenderAddress": approval["spenderAddress"],
+            "previousAllowance": approval["allowance"],
+            "transaction": tx,
+        })
+
+    return {
+        "action": "approval_revoke_all",
+        "chain": {"key": chain.key, "chainId": chain.chain_id},
+        "wallet": resolved_wallet,
+        "dryRun": dry_run,
+        "totalApprovals": len(scan["approvals"]),
+        "revokes": revoke_txs,
+    }
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description="Scan and revoke ERC-20 approvals for Uniswap contracts")
+    sub = parser.add_subparsers(dest="command")
+
+    s = sub.add_parser("scan", help="Scan all non-zero ERC-20 approvals for known spenders")
+    s.add_argument("--chain", required=True)
+    s.add_argument("--wallet", required=True)
+    s.add_argument("--rpc-url")
+    s.add_argument("--output")
+
+    r = sub.add_parser("revoke", help="Revoke a specific token/spender approval")
+    r.add_argument("--chain", required=True)
+    r.add_argument("--wallet", required=True)
+    r.add_argument("--token", required=True, help="Token symbol or address")
+    r.add_argument("--spender", required=True, help="Spender label (positionManager, router02, permit2, universalRouter) or address")
+    r.add_argument("--rpc-url")
+    r.add_argument("--output")
+
+    ra = sub.add_parser("revoke-all", help="Revoke all non-zero approvals (dry-run by default)")
+    ra.add_argument("--chain", required=True)
+    ra.add_argument("--wallet", required=True)
+    ra.add_argument("--rpc-url")
+    ra.add_argument("--execute", action="store_true", help="Actually broadcast revoke transactions")
+    ra.add_argument("--output")
+
+    args = parser.parse_args()
+    load_local_env()
+
+    if args.command == "scan":
+        result = scan_approvals(args.chain, args.wallet, args.rpc_url)
+        n = result["nonZeroApprovals"]
+        print(f"Found {n} non-zero approvals across {result['tokensChecked']} tokens and {result['spendersChecked']} spenders")
+        for a in result["approvals"]:
+            max_flag = " [MAX]" if a["isMaxApproval"] else ""
+            print(f"  {a['token']:8s} -> {a['spenderLabel']:20s} ({a['spenderAddress'][:10]}...){max_flag}  allowance={a['allowance'][:20]}")
+        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 == "revoke":
+        result = revoke_approval(args.chain, args.wallet, args.token, args.spender, args.rpc_url)
+        print(f"Revoke tx: {result['token']} -> {result['spenderLabel']}")
+        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 == "revoke-all":
+        result = revoke_all(args.chain, args.wallet, args.rpc_url, dry_run=not args.execute)
+        mode = "DRY RUN" if result["dryRun"] else "EXECUTE"
+        print(f"Revoke all ({mode}): {result['totalApprovals']} approvals to revoke")
+        for r in result["revokes"]:
+            print(f"  {r['token']:8s} -> {r['spenderLabel']:20s}  (was {r['previousAllowance'][:20]})")
+        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()

uniswap_autopilot/common/check_balance.py

@@ -0,0 +1,64 @@
+#!/usr/bin/env python3
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+
+
+from uniswap_autopilot.common.common import (
+    check_balance,
+    decimal_to_base_units,
+    dump_json,
+    is_native,
+    load_local_env,
+    normalize_chain,
+    parse_amount,
+    resolve_token,
+    resolve_wallet_address,
+)
+from uniswap_autopilot.execute._internal.rpc import resolve_rpc_url
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description="检查钱包代币余额")
+    parser.add_argument("--chain", required=True, help="链名")
+    parser.add_argument("--token", required=True, help="代币 symbol 或地址")
+    parser.add_argument("--amount", help="要检查的数量（人类可读），如 1.5")
+    parser.add_argument("--wallet", help="钱包地址（默认从 env 读取）")
+    parser.add_argument("--rpc-url", help="RPC URL")
+    args = parser.parse_args()
+
+    load_local_env()
+    chain = normalize_chain(args.chain)
+    rpc = args.rpc_url or resolve_rpc_url(None, chain.chain_id)[0]
+
+    wallet = resolve_wallet_address(args.wallet)
+    if not wallet:
+        print(json.dumps({"error": "wallet address required"}), file=sys.stderr)
+        sys.exit(1)
+
+    token = resolve_token(chain, args.token, rpc)
+
+    if args.amount:
+        amount_base = decimal_to_base_units(parse_amount(args.amount), token["decimals"])
+        result = check_balance(chain, token, amount_base, wallet, rpc)
+        result["humanAmount"] = args.amount
+        result["token"] = token["symbol"]
+        result["wallet"] = wallet
+        status = "OK" if result.get("ok") else "INSUFFICIENT"
+        print(f"{status}: {token['symbol']} balance={result.get('balance', '?')} required={amount_base} ({args.amount})")
+    else:
+        from uniswap_autopilot.execute._internal.rpc import query_erc20_balance, query_native_balance
+        if is_native(chain, args.token) or token.get("address") == "NATIVE":
+            raw = query_native_balance(wallet, rpc)
+        else:
+            raw = query_erc20_balance(wallet, token["address"], rpc)
+        result = {"token": token["symbol"], "wallet": wallet, "balance": str(raw), "decimals": token["decimals"]}
+        print(f"{token['symbol']}: balance={raw} ({token['decimals']} decimals)")
+
+    dump_json(result)
+
+
+if __name__ == "__main__":
+    main()