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

uniswap_autopilot/common/deep_link.py

@@ -0,0 +1,132 @@
+#!/usr/bin/env python3
+from __future__ import annotations
+
+import argparse
+import sys
+from urllib.parse import urlencode
+
+
+from uniswap_autopilot.common.common import dump_json, normalize_chain, resolve_token, load_local_env
+
+
+def _swap_url(chain_url_param: str, addr_in: str, addr_out: str) -> str:
+    params = {
+        "chain": chain_url_param,
+        "inputCurrency": addr_in,
+        "outputCurrency": addr_out,
+    }
+    return f"https://app.uniswap.org/swap?{urlencode(params)}"
+
+
+def _lp_url(chain_url_param: str, symbol_a: str, symbol_b: str, fee: int | None = None) -> str:
+    base = f"https://app.uniswap.org/add/{symbol_a}/{symbol_b}?chain={chain_url_param}"
+    if fee is not None:
+        base += f"&fee={fee}"
+    return base
+
+
+def build_swap_link(
+    chain_name: str,
+    token_in_name: str,
+    token_out_name: str,
+) -> dict[str, object]:
+    chain = normalize_chain(chain_name)
+    token_in = resolve_token(chain, token_in_name)
+    token_out = resolve_token(chain, token_out_name)
+
+    # For swap links, native tokens use "NATIVE" as inputCurrency (Uniswap convention)
+    addr_in = "NATIVE" if token_in["address"] == "NATIVE" else token_in["address"]
+    addr_out = "NATIVE" if token_out["address"] == "NATIVE" else token_out["address"]
+
+    url = _swap_url(chain.url_param, addr_in, addr_out)
+
+    print(f"Swap URL: {url}")
+
+    return {
+        "action": "deep_link_swap",
+        "chain": {"key": chain.key, "chainId": chain.chain_id},
+        "tokenIn": token_in,
+        "tokenOut": token_out,
+        "url": url,
+    }
+
+
+def build_lp_link(
+    chain_name: str,
+    token_a_name: str,
+    token_b_name: str,
+    fee_tier: int | None = None,
+) -> dict[str, object]:
+    chain = normalize_chain(chain_name)
+    token_a = resolve_token(chain, token_a_name)
+    token_b = resolve_token(chain, token_b_name)
+
+    # For LP links, use token symbols in the URL path
+    symbol_a = token_a["symbol"]
+    symbol_b = token_b["symbol"]
+
+    url = _lp_url(chain.url_param, symbol_a, symbol_b, fee_tier)
+
+    print(f"LP URL: {url}")
+
+    return {
+        "action": "deep_link_lp",
+        "chain": {"key": chain.key, "chainId": chain.chain_id},
+        "tokenA": token_a,
+        "tokenB": token_b,
+        "feeTier": fee_tier,
+        "url": url,
+    }
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description="Generate app.uniswap.org deep links")
+    sub = parser.add_subparsers(dest="command")
+
+    # swap
+    sw = sub.add_parser("swap", help="Generate a swap deep link")
+    sw.add_argument("--chain", required=True, help="Chain name, e.g. base / ethereum")
+    sw.add_argument("--token-in", required=True, help="Input token symbol, address, or NATIVE")
+    sw.add_argument("--token-out", required=True, help="Output token symbol, address, or NATIVE")
+
+    # lp
+    lp = sub.add_parser("lp", help="Generate an LP deep link")
+    lp.add_argument("--chain", required=True, help="Chain name, e.g. base / ethereum")
+    lp.add_argument("--token-a", required=True, help="Token A symbol or address")
+    lp.add_argument("--token-b", required=True, help="Token B symbol or address")
+    lp.add_argument("--fee-tier", type=int, default=None, help="V3 fee tier (e.g. 3000)")
+
+    args = parser.parse_args()
+
+    try:
+        load_local_env()
+
+        if args.command == "swap":
+            result = build_swap_link(
+                chain_name=args.chain,
+                token_in_name=args.token_in,
+                token_out_name=args.token_out,
+            )
+            dump_json(result)
+
+        elif args.command == "lp":
+            result = build_lp_link(
+                chain_name=args.chain,
+                token_a_name=args.token_a,
+                token_b_name=args.token_b,
+                fee_tier=args.fee_tier,
+            )
+            dump_json(result)
+
+        else:
+            parser.print_help()
+            sys.exit(1)
+
+    except Exception as exc:
+        import json
+        print(json.dumps({"error": str(exc)}, ensure_ascii=False, indent=2), file=sys.stderr)
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

uniswap_autopilot/common/gas.py

@@ -0,0 +1,141 @@
+#!/usr/bin/env python3
+from __future__ import annotations
+
+import argparse
+from typing import Any
+
+
+from uniswap_autopilot.common.common import dump_json, load_local_env, normalize_chain, PUBLIC_RPC_URLS
+from uniswap_autopilot.execute._internal.rpc import (
+    build_calldata, encode_uint, eth_fee_history, query_gas_price, resolve_rpc_url,
+)
+
+L2_UNWRAP_CHAINS = {
+    "base", "arbitrum", "optimism", "polygon", "unichain",
+    "linea", "blast", "zora", "world_chain", "soneium",
+}
+
+SPEED_PERCENTILE = {"slow": 15, "standard": 50, "fast": 85}
+
+
+def estimate_gas_price(
+    chain_name: str,
+    speed: str = "standard",
+) -> dict[str, Any]:
+    chain = normalize_chain(chain_name)
+    rpc_url = PUBLIC_RPC_URLS.get(chain.key) or resolve_rpc_url(None, chain.chain_id)[0]
+    if not rpc_url:
+        raise RuntimeError(f"RPC URL not configured for {chain_name}")
+
+    result: dict[str, Any] = {
+        "chain": {"key": chain.key, "chainId": chain.chain_id},
+        "speed": speed,
+    }
+
+    # Try EIP-1559 fee history
+    try:
+        data = eth_fee_history(4, "latest", rpc_url, reward_percentiles=[25, 50, 75])
+        base_fee_hex = (data.get("baseFeePerGas") or [])[-1]
+        base_fee = int(base_fee_hex, 16) if base_fee_hex else None
+        result["baseFee"] = base_fee
+
+        rewards = data.get("reward") or []
+        if rewards and rewards[0] and rewards[-1]:
+            pct = SPEED_PERCENTILE.get(speed, 50)
+            idx = min(pct // 25, len(rewards[0]) - 1)
+            priority_hex = rewards[-1][idx] if idx < len(rewards[-1]) else "0x0"
+            priority_fee = int(priority_hex, 16)
+        else:
+            priority_fee = 1_500_000_000  # 1.5 gwei default
+        result["priorityFee"] = priority_fee
+        result["totalEstimate"] = (base_fee or 0) + priority_fee
+        result["mode"] = "eip1559"
+    except Exception:
+        # Fallback to legacy gas price
+        try:
+            gas_price = query_gas_price(rpc_url)
+            result["gasPriceLegacy"] = gas_price
+            result["totalEstimate"] = gas_price
+            result["mode"] = "legacy"
+        except Exception as exc:
+            result["error"] = str(exc)
+            result["totalEstimate"] = 0
+
+    return result
+
+
+def check_weth_unwrap_needed(
+    chain_name: str,
+    token_out_info: dict[str, Any],
+    original_token_out: str,
+) -> bool:
+    if chain_name not in L2_UNWRAP_CHAINS:
+        return False
+    chain = normalize_chain(chain_name)
+    wrapped = chain.tokens.get(chain.wrapped_native_symbol.upper())
+    if not wrapped:
+        return False
+    if token_out_info.get("address", "").lower() != wrapped.address.lower():
+        return False
+    upper = original_token_out.strip().upper()
+    return upper in {"NATIVE", chain.native_symbol.upper()}
+
+
+def build_weth_unwrap_tx(
+    chain_name: str,
+    amount_wei: str,
+    wallet: str,
+) -> dict[str, Any]:
+    chain = normalize_chain(chain_name)
+    wrapped = chain.tokens.get(chain.wrapped_native_symbol.upper())
+    if not wrapped:
+        raise ValueError(f"wrapped native not configured for {chain_name}")
+
+    calldata = build_calldata("withdraw(uint256)", encode_uint(int(amount_wei)))
+
+    return {
+        "action": "weth_unwrap",
+        "chain": {"key": chain.key, "chainId": chain.chain_id},
+        "wethAddress": wrapped.address,
+        "amountWei": amount_wei,
+        "transaction": {
+            "kind": "weth_unwrap",
+            "to": wrapped.address,
+            "data": calldata,
+            "value": "0",
+            "chainId": chain.chain_id,
+            "from": wallet,
+        },
+    }
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description="Gas price estimation and WETH unwrap utilities")
+    sub = parser.add_subparsers(dest="command")
+
+    g = sub.add_parser("estimate", help="Estimate gas price for a chain")
+    g.add_argument("--chain", required=True)
+    g.add_argument("--speed", choices=["slow", "standard", "fast"], default="standard")
+
+    w = sub.add_parser("unwrap", help="Build WETH.unwrap transaction")
+    w.add_argument("--chain", required=True)
+    w.add_argument("--amount-wei", required=True, help="Amount in wei to unwrap")
+    w.add_argument("--wallet", required=True)
+
+    args = parser.parse_args()
+    load_local_env()
+
+    if args.command == "estimate":
+        result = estimate_gas_price(args.chain, args.speed)
+        total_gwei = result["totalEstimate"] / 1e9
+        print(f"Gas estimate ({args.speed}): {total_gwei:.2f} gwei ({result.get('mode', 'unknown')})")
+        dump_json(result)
+    elif args.command == "unwrap":
+        result = build_weth_unwrap_tx(args.chain, args.amount_wei, args.wallet)
+        dump_json(result)
+    else:
+        parser.print_help()
+
+
+if __name__ == "__main__":
+    main()

uniswap_autopilot/data/auto_trade_policy.example.json

@@ -0,0 +1,29 @@
+{
+  "enabled": false,
+  "allowedChains": [
+    "base"
+  ],
+  "allowedPairs": [
+    {
+      "chain": "base",
+      "tokenIn": "USDC",
+      "tokenOut": "WETH",
+      "maxAmount": "100",
+      "maxSlippage": 0.5,
+      "allowAutoSignPermit": false,
+      "allowAutoApproval": false,
+      "allowAutoBroadcastSwap": false
+    },
+    {
+      "chain": "base",
+      "tokenIn": "NATIVE",
+      "tokenOut": "USDC",
+      "maxAmount": "0.1",
+      "maxSlippage": 0.5,
+      "allowAutoSignPermit": false,
+      "allowAutoApproval": false,
+      "allowAutoBroadcastSwap": false
+    }
+  ],
+  "requirePreflightOk": true
+}

uniswap_autopilot/data/chains.json

@@ -0,0 +1,135 @@
+{
+  "ethereum": {
+    "chainId": 1,
+    "nativeSymbol": "ETH",
+    "wrappedNativeSymbol": "WETH",
+    "urlParam": "ethereum",
+    "geckoterminalNetworkId": "eth"
+  },
+  "optimism": {
+    "chainId": 10,
+    "nativeSymbol": "ETH",
+    "wrappedNativeSymbol": "WETH",
+    "urlParam": "optimism",
+    "geckoterminalNetworkId": "optimism"
+  },
+  "bsc": {
+    "chainId": 56,
+    "nativeSymbol": "BNB",
+    "wrappedNativeSymbol": "WBNB",
+    "urlParam": "bnb",
+    "geckoterminalNetworkId": "bsc"
+  },
+  "unichain": {
+    "chainId": 130,
+    "nativeSymbol": "ETH",
+    "wrappedNativeSymbol": "WETH",
+    "urlParam": "unichain",
+    "geckoterminalNetworkId": "unichain"
+  },
+  "polygon": {
+    "chainId": 137,
+    "nativeSymbol": "MATIC",
+    "wrappedNativeSymbol": "WMATIC",
+    "urlParam": "polygon",
+    "geckoterminalNetworkId": "polygon_pos"
+  },
+  "monad": {
+    "chainId": 143,
+    "nativeSymbol": "MON",
+    "wrappedNativeSymbol": "WMON",
+    "urlParam": "monad",
+    "geckoterminalNetworkId": "monad"
+  },
+  "x_layer": {
+    "chainId": 196,
+    "nativeSymbol": "OKB",
+    "wrappedNativeSymbol": "WOKB",
+    "urlParam": "xlayer",
+    "geckoterminalNetworkId": "xlayer"
+  },
+  "zksync": {
+    "chainId": 324,
+    "nativeSymbol": "ETH",
+    "wrappedNativeSymbol": "WETH",
+    "urlParam": "zksync",
+    "geckoterminalNetworkId": "zksync"
+  },
+  "world_chain": {
+    "chainId": 480,
+    "nativeSymbol": "ETH",
+    "wrappedNativeSymbol": "WETH",
+    "urlParam": "worldchain",
+    "geckoterminalNetworkId": "worldchain"
+  },
+  "soneium": {
+    "chainId": 1868,
+    "nativeSymbol": "ETH",
+    "wrappedNativeSymbol": "WETH",
+    "urlParam": "soneium",
+    "geckoterminalNetworkId": "soneium"
+  },
+  "tempo": {
+    "chainId": 4217,
+    "nativeSymbol": "AVAX",
+    "wrappedNativeSymbol": "WAVAX",
+    "urlParam": "tempo",
+    "geckoterminalNetworkId": "tempo"
+  },
+  "base": {
+    "chainId": 8453,
+    "nativeSymbol": "ETH",
+    "wrappedNativeSymbol": "WETH",
+    "urlParam": "base",
+    "geckoterminalNetworkId": "base"
+  },
+  "arbitrum": {
+    "chainId": 42161,
+    "nativeSymbol": "ETH",
+    "wrappedNativeSymbol": "WETH",
+    "urlParam": "arbitrum",
+    "geckoterminalNetworkId": "arbitrum"
+  },
+  "celo": {
+    "chainId": 42220,
+    "nativeSymbol": "CELO",
+    "wrappedNativeSymbol": "CELO",
+    "urlParam": "celo",
+    "geckoterminalNetworkId": "celo"
+  },
+  "avalanche": {
+    "chainId": 43114,
+    "nativeSymbol": "AVAX",
+    "wrappedNativeSymbol": "WAVAX",
+    "urlParam": "avalanche",
+    "geckoterminalNetworkId": "avax"
+  },
+  "linea": {
+    "chainId": 59144,
+    "nativeSymbol": "ETH",
+    "wrappedNativeSymbol": "WETH",
+    "urlParam": "linea",
+    "geckoterminalNetworkId": "linea"
+  },
+  "blast": {
+    "chainId": 81457,
+    "nativeSymbol": "ETH",
+    "wrappedNativeSymbol": "WETH",
+    "urlParam": "blast",
+    "geckoterminalNetworkId": "blast"
+  },
+  "zora": {
+    "chainId": 7777777,
+    "nativeSymbol": "ETH",
+    "wrappedNativeSymbol": "WETH",
+    "urlParam": "zora",
+    "geckoterminalNetworkId": "zora"
+  },
+  "ink": {
+    "chainId": 57073,
+    "nativeSymbol": "ETH",
+    "wrappedNativeSymbol": "WETH",
+    "urlParam": "ink",
+    "geckoterminalNetworkId": "ink"
+  }
+}