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

uniswap_autopilot/lp/v3/pool.py

@@ -0,0 +1,175 @@
+#!/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_v3_factory_address,
+    load_local_env,
+    normalize_chain,
+    resolve_token,
+    sort_token_addresses,
+    validate_fee_tier,
+)
+from uniswap_autopilot.execute._internal.rpc import (
+    decode_address, decode_int256, decode_uint, encode_address, encode_selector,
+    encode_uint, eth_call, resolve_rpc_url,
+)
+from uniswap_autopilot.lp.v3.tick import fee_tier_to_tick_spacing, tick_to_price
+
+
+def query_pool_address(token0: str, token1: str, fee: int, factory: str, rpc_url: str) -> str:
+    sel = encode_selector("getPool(address,address,uint24)")
+    data = sel + encode_address(token0).replace("0x", "") + encode_address(token1).replace("0x", "") + encode_uint(fee).replace("0x", "")
+    raw = eth_call(factory, data, rpc_url)
+    addr = decode_address(raw)
+    if addr == "0x" + "0" * 40:
+        return "0x0000000000000000000000000000000000000000"
+    return addr
+
+
+def query_slot0(pool_address: str, rpc_url: str) -> dict[str, Any]:
+    sel = encode_selector("slot0()")
+    raw = eth_call(pool_address, sel, rpc_url)
+    clean = raw.replace("0x", "")
+    # slot0 returns 7 values: uint160, int24, uint16, uint16, uint16, uint8, bool
+    if len(clean) < 7 * 64:
+        raise RuntimeError(f"slot0 returned unexpected output: {raw}")
+    sqrt_price_x96 = decode_uint("0x" + clean[0:64])
+    tick = decode_int256("0x" + clean[64:128])
+    observation_index = decode_uint("0x" + clean[128:192])
+    observation_cardinality = decode_uint("0x" + clean[192:256])
+    observation_cardinality_next = decode_uint("0x" + clean[256:320])
+    fee_protocol = decode_uint("0x" + clean[320:384])
+    unlocked = decode_uint("0x" + clean[384:448]) != 0
+    return {
+        "sqrtPriceX96": sqrt_price_x96,
+        "tick": tick,
+        "observationIndex": observation_index,
+        "observationCardinality": observation_cardinality,
+        "observationCardinalityNext": observation_cardinality_next,
+        "feeProtocol": fee_protocol,
+        "unlocked": unlocked,
+    }
+
+
+def query_pool_liquidity(pool_address: str, rpc_url: str) -> int:
+    sel = encode_selector("liquidity()")
+    raw = eth_call(pool_address, sel, rpc_url)
+    return decode_uint(raw)
+
+
+def query_pool_tokens(pool_address: str, rpc_url: str) -> tuple[str, str]:
+    sel0 = encode_selector("token0()")
+    raw0 = eth_call(pool_address, sel0, rpc_url)
+    t0 = decode_address(raw0)
+    sel1 = encode_selector("token1()")
+    raw1 = eth_call(pool_address, sel1, rpc_url)
+    t1 = decode_address(raw1)
+    return t0, t1
+
+
+def query_pool_fee(pool_address: str, rpc_url: str) -> int:
+    sel = encode_selector("fee()")
+    raw = eth_call(pool_address, sel, rpc_url)
+    return decode_uint(raw)
+
+
+def query_pool_full_info(
+    chain_name: str,
+    token_a: str,
+    token_b: str,
+    fee_tier: int,
+    rpc_url: str | None = None,
+) -> dict[str, Any]:
+    chain = normalize_chain(chain_name)
+    rpc, _ = resolve_rpc_url(rpc_url, chain.chain_id)
+    token_a_info = resolve_token(chain, token_a, rpc)
+    token_b_info = resolve_token(chain, token_b, rpc)
+    fee = validate_fee_tier(fee_tier)
+
+    def _resolve_addr(info: dict[str, Any]) -> str:
+        if info["address"] != "NATIVE":
+            return info["address"]
+        wrapped = chain.tokens.get(chain.wrapped_native_symbol.upper())
+        if not wrapped:
+            raise ValueError(f"wrapped native token not configured for chain '{chain.key}'")
+        return wrapped.address
+
+    addr_a = _resolve_addr(token_a_info)
+    addr_b = _resolve_addr(token_b_info)
+    token0_addr, token1_addr = sort_token_addresses(addr_a, addr_b)
+
+    factory = get_v3_factory_address(chain_name)
+    if not rpc:
+        raise RuntimeError(f"RPC URL not configured for {chain_name}; set {chain_name.upper()}_RPC_URL")
+
+    pool_address = query_pool_address(token0_addr, token1_addr, fee, factory, rpc)
+    if pool_address == "0x0000000000000000000000000000000000000000":
+        return {
+            "action": "pool_info",
+            "chain": {"key": chain.key, "chainId": chain.chain_id},
+            "tokenA": token_a_info,
+            "tokenB": token_b_info,
+            "token0": token0_addr,
+            "token1": token1_addr,
+            "feeTier": fee,
+            "poolAddress": None,
+            "exists": False,
+        }
+
+    slot0 = query_slot0(pool_address, rpc)
+    liquidity = query_pool_liquidity(pool_address, rpc)
+    tick_spacing = fee_tier_to_tick_spacing(fee)
+
+    decimals0 = token_a_info["decimals"] if token0_addr == addr_a else token_b_info["decimals"]
+    decimals1 = token_b_info["decimals"] if token1_addr == addr_b else token_a_info["decimals"]
+    current_price = tick_to_price(slot0["tick"], decimals0, decimals1)
+
+    return {
+        "action": "pool_info",
+        "chain": {"key": chain.key, "chainId": chain.chain_id},
+        "tokenA": token_a_info,
+        "tokenB": token_b_info,
+        "token0": token0_addr,
+        "token1": token1_addr,
+        "feeTier": fee,
+        "tickSpacing": tick_spacing,
+        "poolAddress": pool_address,
+        "exists": True,
+        "slot0": slot0,
+        "currentTick": slot0["tick"],
+        "currentPrice": current_price,
+        "liquidity": str(liquidity),
+    }
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description="查询 Uniswap v3 池子状态")
+    parser.add_argument("--chain", required=True, help="链名，例如 base / ethereum")
+    parser.add_argument("--token-a", required=True, help="代币 symbol 或地址")
+    parser.add_argument("--token-b", required=True, help="代币 symbol 或地址")
+    parser.add_argument("--fee-tier", type=int, required=True, help="手续费等级: 100 / 500 / 3000 / 10000")
+    parser.add_argument("--rpc-url", help="RPC URL，不提供则从环境变量读取")
+    parser.add_argument("--output", help="输出 JSON 文件路径")
+    args = parser.parse_args()
+
+    try:
+        load_local_env()
+        result = query_pool_full_info(args.chain, args.token_a, args.token_b, args.fee_tier, args.rpc_url)
+        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/position.py

@@ -0,0 +1,112 @@
+#!/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,
+)
+from uniswap_autopilot.execute._internal.rpc import (
+    decode_address, decode_int256, decode_uint, encode_address, encode_selector,
+    encode_uint, eth_call, resolve_rpc_url,
+)
+
+
+def query_position(token_id: int, 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}")
+
+    sel = encode_selector("positions(uint256)")
+    data = sel + encode_uint(token_id).replace("0x", "")
+    raw = eth_call(pm, data, rpc)
+    clean = raw.replace("0x", "")
+    # positions returns 12 uint256/int256/address values
+    if len(clean) < 12 * 64:
+        raise RuntimeError(f"positions() returned unexpected output: {raw}")
+
+    def _u(offset: int) -> int:
+        return decode_uint("0x" + clean[offset:offset + 64])
+
+    def _i(offset: int) -> int:
+        return decode_int256("0x" + clean[offset:offset + 64])
+
+    def _a(offset: int) -> str:
+        return decode_address("0x" + clean[offset:offset + 64])
+
+    return {
+        "tokenId": token_id,
+        "nonce": _u(0),
+        "operator": _a(64),
+        "token0": _a(128),
+        "token1": _a(192),
+        "fee": _u(256),
+        "tickLower": _i(320),
+        "tickUpper": _i(384),
+        "liquidity": str(_u(448)),
+        "feeGrowthInside0LastX128": str(_u(512)),
+        "feeGrowthInside1LastX128": str(_u(576)),
+        "tokensOwed0": str(_u(640)),
+        "tokensOwed1": str(_u(704)),
+    }
+
+
+def query_positions_by_owner(owner: str, chain_name: str, rpc_url: str | None = None) -> list[int]:
+    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}")
+
+    bal_sel = encode_selector("balanceOf(address)")
+    bal_data = bal_sel + encode_address(owner).replace("0x", "")
+    raw_bal = eth_call(pm, bal_data, rpc)
+    balance = decode_uint(raw_bal)
+
+    token_ids: list[int] = []
+    tobi_sel = encode_selector("tokenOfOwnerByIndex(address,uint256)")
+    for i in range(balance):
+        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 v3 LP 仓位信息")
+    parser.add_argument("--chain", required=True, help="链名")
+    source = parser.add_mutually_exclusive_group(required=True)
+    source.add_argument("--token-id", type=int, help="LP NFT token ID")
+    source.add_argument("--owner", help="钱包地址，列出所有仓位")
+    parser.add_argument("--rpc-url", help="RPC URL")
+    parser.add_argument("--output", help="输出 JSON 文件路径")
+    args = parser.parse_args()
+
+    try:
+        load_local_env()
+        if args.token_id is not None:
+            result = {"action": "position_info", "position": query_position(args.token_id, args.chain, args.rpc_url)}
+        else:
+            token_ids = query_positions_by_owner(args.owner, args.chain, args.rpc_url)
+            positions = [query_position(tid, args.chain, args.rpc_url) for tid in token_ids]
+            result = {"action": "positions_by_owner", "owner": args.owner, "count": len(positions), "positions": positions}
+        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/tick.py

@@ -0,0 +1,75 @@
+#!/usr/bin/env python3
+from __future__ import annotations
+
+from decimal import Decimal
+
+MIN_TICK = -887272
+MAX_TICK = 887272
+
+_TICK_SPACING_BY_FEE: dict[int, int] = {
+    100: 1,
+    500: 10,
+    3000: 60,
+    10000: 200,
+}
+
+
+def fee_tier_to_tick_spacing(fee: int) -> int:
+    if fee not in _TICK_SPACING_BY_FEE:
+        raise ValueError(f"unknown fee tier {fee}; valid: {sorted(_TICK_SPACING_BY_FEE)}")
+    return _TICK_SPACING_BY_FEE[fee]
+
+
+def nearest_usable_tick(tick: int, tick_spacing: int) -> int:
+    if tick_spacing <= 0:
+        raise ValueError(f"tick_spacing must be positive, got {tick_spacing}")
+    rounded = round(tick / tick_spacing) * tick_spacing
+    return max(MIN_TICK, min(MAX_TICK, rounded))
+
+
+def price_to_tick(price: float, decimals0: int, decimals1: int) -> int:
+    if price <= 0:
+        raise ValueError("price must be positive")
+    adjusted = Decimal(str(price)) * (Decimal(10) ** (decimals0 - decimals1))
+    tick = int(adjusted.ln() / Decimal("1.0001").ln())
+    return max(MIN_TICK, min(MAX_TICK, tick))
+
+
+def tick_to_price(tick: int, decimals0: int, decimals1: int) -> float:
+    adjusted = Decimal("1.0001") ** tick
+    price = adjusted * (Decimal(10) ** (decimals1 - decimals0))
+    return float(price)
+
+
+def tick_to_sqrt_price_x96(tick: int) -> int:
+    adjusted = Decimal("1.0001") ** tick
+    sqrt_price = adjusted.sqrt()
+    return int(sqrt_price * (Decimal(2) ** 96))
+
+
+def suggest_ticks_for_range(
+    current_tick: int,
+    tick_spacing: int,
+    price_lower: float | None = None,
+    price_upper: float | None = None,
+    decimals0: int = 18,
+    decimals1: int = 18,
+) -> tuple[int, int]:
+    if price_lower is not None and price_upper is not None:
+        lower = price_to_tick(price_lower, decimals0, decimals1)
+        upper = price_to_tick(price_upper, decimals0, decimals1)
+    elif price_lower is not None:
+        lower = price_to_tick(price_lower, decimals0, decimals1)
+        upper = MAX_TICK
+    elif price_upper is not None:
+        lower = MIN_TICK
+        upper = price_to_tick(price_upper, decimals0, decimals1)
+    else:
+        return (
+            nearest_usable_tick(MIN_TICK, tick_spacing),
+            nearest_usable_tick(MAX_TICK, tick_spacing),
+        )
+    return (
+        nearest_usable_tick(lower, tick_spacing),
+        nearest_usable_tick(upper, tick_spacing),
+    )

uniswap_autopilot/lp/v4/approve.py

@@ -0,0 +1,105 @@
+#!/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,
+    resolve_token,
+)
+from uniswap_autopilot.execute._internal.rpc import (
+    build_calldata, encode_address, encode_uint, query_erc20_allowance, resolve_rpc_url,
+)
+
+
+def check_v4_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_v4_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": "v4_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(spender: str, amount: str | None = 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_v4_position_manager_address(chain_name)
+    calldata = build_approval_calldata(pm, amount)
+    return {
+        "kind": "approval",
+        "to": token,
+        "data": calldata,
+        "value": "0",
+        "chainId": chain.chain_id,
+        "from": owner,
+    }
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description="Check ERC-20 approvals for V4 PositionManager")
+    parser.add_argument("--chain", required=True)
+    parser.add_argument("--token-a", required=True)
+    parser.add_argument("--token-b", required=True)
+    parser.add_argument("--owner", required=True)
+    parser.add_argument("--rpc-url")
+    parser.add_argument("--output")
+    args = parser.parse_args()
+
+    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_v4_approvals(t0, t1, args.owner, args.chain, args.rpc_url)
+    for key in ("token0", "token1"):
+        if result[key]["needsApproval"]:
+            result[key]["approvalTx"] = build_approval_tx(
+                result[key]["address"], 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)
+
+
+if __name__ == "__main__":
+    main()