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

uniswap_autopilot/lp/v2/approve.py

@@ -0,0 +1,100 @@
+#!/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_v2_router02_address,
+    load_local_env,
+    normalize_chain,
+    resolve_token,
+    sort_token_addresses,
+)
+from uniswap_autopilot.execute._internal.rpc import (
+    build_calldata, encode_address, encode_uint, query_erc20_allowance,
+)
+
+
+def check_v2_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)
+    router02 = get_v2_router02_address(chain_name)
+
+    result = {"action": "v2_approval_check", "owner": owner, "spender": router02}
+
+    for label, token_addr in [("token0", token0_address), ("token1", token1_address)]:
+        try:
+            allowance = query_erc20_allowance(token_addr, owner, router02, rpc_url)
+        except Exception as exc:
+            allowance = 0
+            result[label] = {"queryError": str(exc)}
+        result[label] = {
+            "address": token_addr,
+            "allowance": str(allowance),
+            "needsApproval": allowance == 0,
+        }
+
+    return result
+
+
+def build_v2_approval_tx(
+    token_address: str,
+    owner: str,
+    chain_name: str,
+    amount: str | None = None,
+) -> dict[str, Any]:
+    chain = normalize_chain(chain_name)
+    router02 = get_v2_router02_address(chain_name)
+    approve_amount = amount or "115792089237316195423570985008687907853269984665640564039457584007913129639935"
+
+    calldata = build_calldata(
+        "approve(address,uint256)",
+        encode_address(router02),
+        encode_uint(int(approve_amount)),
+    )
+
+    return {
+        "kind": "approval",
+        "to": token_address,
+        "data": calldata,
+        "value": "0",
+        "chainId": chain.chain_id,
+        "from": owner,
+    }
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description="检查 V2 LP approval 状态")
+    parser.add_argument("--chain", required=True, help="链名")
+    parser.add_argument("--token-a", required=True, help="代币 A")
+    parser.add_argument("--token-b", required=True, help="代币 B")
+    parser.add_argument("--owner", required=True, help="钱包地址")
+    parser.add_argument("--rpc-url", help="RPC URL")
+    parser.add_argument("--output", help="输出 JSON 文件路径")
+    args = parser.parse_args()
+
+    load_local_env()
+    chain = normalize_chain(args.chain)
+
+    tok_a = resolve_token(chain, args.token_a)
+    tok_b = resolve_token(chain, args.token_b)
+    token0, token1 = sort_token_addresses(tok_a["address"], tok_b["address"])
+
+    result = check_v2_approvals(token0, token1, args.owner, args.chain, args.rpc_url)
+    dump_json(result)
+    if args.output:
+        Path(args.output).write_text(json.dumps(result, ensure_ascii=False, indent=2) + "\n", encoding="utf-8")
+
+
+if __name__ == "__main__":
+    main()

uniswap_autopilot/lp/v2/build_tx.py

@@ -0,0 +1,226 @@
+#!/usr/bin/env python3
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+import time
+from pathlib import Path
+from typing import Any
+
+
+from uniswap_autopilot.common.common import (
+    decimal_to_base_units,
+    dump_json,
+    get_v2_router02_address,
+    load_local_env,
+    normalize_chain,
+    parse_amount,
+    resolve_token,
+    resolve_wallet_address,
+    sort_token_addresses,
+)
+from uniswap_autopilot.execute._internal.rpc import build_calldata, encode_address, encode_uint
+from uniswap_autopilot.lp.v2.pair import query_pair_full_info
+
+
+def _apply_slippage(amount_base_units: str, slippage_pct: float) -> str:
+    from decimal import Decimal
+    amount = Decimal(amount_base_units)
+    factor = Decimal("1") - Decimal(str(slippage_pct)) / Decimal("100")
+    return str(int(amount * factor))
+
+
+def build_add_liquidity_tx(
+    chain_name: str,
+    token_a: str,
+    token_b: str,
+    amount_a: str,
+    amount_b: str,
+    slippage_pct: float = 0.5,
+    recipient: str | None = None,
+    deadline_seconds: int = 600,
+    rpc_url: str | None = None,
+) -> dict[str, Any]:
+    chain = normalize_chain(chain_name)
+    router02 = get_v2_router02_address(chain_name)
+
+    tok_a = resolve_token(chain, token_a, rpc_url)
+    tok_b = resolve_token(chain, token_b, rpc_url)
+    if tok_a["address"] == "NATIVE" or tok_b["address"] == "NATIVE":
+        raise ValueError("V2 LP does not support NATIVE token; use wrapped token (e.g. WETH instead of ETH)")
+    token0, token1 = sort_token_addresses(tok_a["address"], tok_b["address"])
+
+    # Map amounts to sorted token order
+    if tok_a["address"].lower() == token0.lower():
+        amount0_human, amount1_human = amount_a, amount_b
+        dec0, dec1 = tok_a["decimals"], tok_b["decimals"]
+    else:
+        amount0_human, amount1_human = amount_b, amount_a
+        dec0, dec1 = tok_b["decimals"], tok_a["decimals"]
+
+    amount0_desired = decimal_to_base_units(parse_amount(amount0_human), dec0)
+    amount1_desired = decimal_to_base_units(parse_amount(amount1_human), dec1)
+    amount0_min = _apply_slippage(amount0_desired, slippage_pct)
+    amount1_min = _apply_slippage(amount1_desired, slippage_pct)
+
+    to = recipient or resolve_wallet_address(None) or ""
+    if not to:
+        raise ValueError("recipient wallet address is required (--recipient or configure wallet env)")
+
+    deadline = str(int(time.time()) + deadline_seconds)
+
+    calldata = build_calldata(
+        "addLiquidity(address,address,uint256,uint256,uint256,uint256,address,uint256)",
+        encode_address(token0),
+        encode_address(token1),
+        encode_uint(int(amount0_desired)),
+        encode_uint(int(amount1_desired)),
+        encode_uint(int(amount0_min)),
+        encode_uint(int(amount1_min)),
+        encode_address(to),
+        encode_uint(int(deadline)),
+    )
+
+    return {
+        "action": "v2_add_liquidity",
+        "chain": {"key": chain.key, "chainId": chain.chain_id},
+        "token0": {"address": token0, "decimals": dec0, "amountDesired": amount0_desired, "amountMin": amount0_min},
+        "token1": {"address": token1, "decimals": dec1, "amountDesired": amount1_desired, "amountMin": amount1_min},
+        "recipient": to,
+        "deadline": deadline,
+        "transaction": {
+            "kind": "v2_add_liquidity",
+            "to": router02,
+            "data": calldata,
+            "value": "0",
+            "chainId": chain.chain_id,
+            "from": to,
+        },
+    }
+
+
+def build_remove_liquidity_tx(
+    chain_name: str,
+    token_a: str,
+    token_b: str,
+    liquidity: str,
+    slippage_pct: float = 0.5,
+    recipient: str | None = None,
+    deadline_seconds: int = 600,
+    rpc_url: str | None = None,
+) -> dict[str, Any]:
+    chain = normalize_chain(chain_name)
+    router02 = get_v2_router02_address(chain_name)
+
+    tok_a = resolve_token(chain, token_a, rpc_url)
+    tok_b = resolve_token(chain, token_b, rpc_url)
+    token0, token1 = sort_token_addresses(tok_a["address"], tok_b["address"])
+    if tok_a["address"].lower() == token0.lower():
+        dec0, dec1 = tok_a["decimals"], tok_b["decimals"]
+    else:
+        dec0, dec1 = tok_b["decimals"], tok_a["decimals"]
+
+    deadline = str(int(time.time()) + deadline_seconds)
+    to = recipient or resolve_wallet_address(None) or ""
+
+    # Query current reserves to estimate minimum amounts
+    pair_info = query_pair_full_info(chain_name, tok_a["address"], tok_b["address"], rpc_url)
+    if not pair_info.get("exists"):
+        raise ValueError(f"V2 pair {tok_a['symbol']}/{tok_b['symbol']} does not exist on {chain_name}")
+
+    reserves = pair_info.get("reserves", {})
+    total_supply = int(pair_info.get("totalSupply", "1"))
+    liquidity_int = int(liquidity)
+
+    # Pro-rata: amount_min = (liquidity * reserve) / totalSupply * (1 - slippage)
+    from decimal import Decimal
+    reserve0 = reserves.get("reserve0", 0)
+    reserve1 = reserves.get("reserve1", 0)
+
+    share0 = Decimal(liquidity_int) * Decimal(reserve0) / Decimal(total_supply)
+    share1 = Decimal(liquidity_int) * Decimal(reserve1) / Decimal(total_supply)
+    factor = Decimal("1") - Decimal(str(slippage_pct)) / Decimal("100")
+    amount0_min = str(int(share0 * factor))
+    amount1_min = str(int(share1 * factor))
+
+    calldata = build_calldata(
+        "removeLiquidity(address,address,uint256,uint256,uint256,address,uint256)",
+        encode_address(token0),
+        encode_address(token1),
+        encode_uint(int(liquidity_int)),
+        encode_uint(int(amount0_min)),
+        encode_uint(int(amount1_min)),
+        encode_address(to),
+        encode_uint(int(deadline)),
+    )
+
+    return {
+        "action": "v2_remove_liquidity",
+        "chain": {"key": chain.key, "chainId": chain.chain_id},
+        "token0": {"address": token0, "decimals": dec0, "amountMin": amount0_min},
+        "token1": {"address": token1, "decimals": dec1, "amountMin": amount1_min},
+        "liquidity": str(liquidity_int),
+        "recipient": to,
+        "deadline": deadline,
+        "transaction": {
+            "kind": "v2_remove_liquidity",
+            "to": router02,
+            "data": calldata,
+            "value": "0",
+            "chainId": chain.chain_id,
+            "from": to,
+        },
+    }
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description="构建 V2 LP 交易")
+    sub = parser.add_subparsers(dest="command")
+
+    add = sub.add_parser("add", help="构建 addLiquidity 交易")
+    add.add_argument("--chain", required=True, help="链名")
+    add.add_argument("--token-a", required=True, help="代币 A")
+    add.add_argument("--token-b", required=True, help="代币 B")
+    add.add_argument("--amount-a", required=True, help="代币 A 数量")
+    add.add_argument("--amount-b", required=True, help="代币 B 数量")
+    add.add_argument("--slippage", type=float, default=0.5, help="滑点百分比，默认 0.5")
+    add.add_argument("--recipient", help="接收地址")
+    add.add_argument("--rpc-url", help="RPC URL")
+    add.add_argument("--output", help="输出 JSON 文件路径")
+
+    remove = sub.add_parser("remove", help="构建 removeLiquidity 交易")
+    remove.add_argument("--chain", required=True, help="链名")
+    remove.add_argument("--token-a", required=True, help="代币 A")
+    remove.add_argument("--token-b", required=True, help="代币 B")
+    remove.add_argument("--liquidity", required=True, help="要移除的 LP token 数量（base units）")
+    remove.add_argument("--slippage", type=float, default=0.5, help="滑点百分比")
+    remove.add_argument("--recipient", help="接收地址")
+    remove.add_argument("--rpc-url", help="RPC URL")
+    remove.add_argument("--output", help="输出 JSON 文件路径")
+
+    args = parser.parse_args()
+    load_local_env()
+
+    if args.command == "add":
+        result = build_add_liquidity_tx(
+            args.chain, args.token_a, args.token_b,
+            args.amount_a, args.amount_b,
+            args.slippage, args.recipient, rpc_url=args.rpc_url,
+        )
+    elif args.command == "remove":
+        result = build_remove_liquidity_tx(
+            args.chain, args.token_a, args.token_b,
+            args.liquidity, args.slippage, args.recipient, rpc_url=args.rpc_url,
+        )
+    else:
+        parser.print_help()
+        sys.exit(1)
+
+    dump_json(result)
+    if args.output:
+        Path(args.output).write_text(json.dumps(result, ensure_ascii=False, indent=2) + "\n", encoding="utf-8")
+
+
+if __name__ == "__main__":
+    main()

uniswap_autopilot/lp/v2/flow.py

@@ -0,0 +1,204 @@
+#!/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,
+    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.approve import build_v2_approval_tx, check_v2_approvals
+from uniswap_autopilot.lp.v2.build_tx import build_add_liquidity_tx, build_remove_liquidity_tx
+from uniswap_autopilot.lp.v2.pair import query_lp_balance, query_pair_full_info
+
+
+def run_v2_add_liquidity_flow(
+    chain_name: str,
+    token_a: str,
+    token_b: str,
+    amount_a: str,
+    amount_b: str,
+    slippage: float = 0.5,
+    wallet: str | None = None,
+    rpc_url: str | None = None,
+    output_dir: str | None = None,
+    broadcast_args: argparse.Namespace | None = None,
+) -> dict[str, Any]:
+    chain = normalize_chain(chain_name)
+    wallet_addr = resolve_wallet_address(wallet)
+    if not wallet_addr:
+        raise ValueError("wallet address required (--wallet or configure wallet env)")
+
+    rpc = rpc_url or resolve_rpc_url(None, chain.chain_id)[0]
+    if not rpc:
+        raise RuntimeError(f"RPC URL not configured for {chain_name}; set an RPC env var or pass --rpc-url")
+
+    # 1. Query pair info
+    pair_info = query_pair_full_info(chain_name, token_a, token_b, rpc)
+
+    # 2. Check approvals
+    if pair_info.get("exists"):
+        token0 = pair_info["token0"]
+        token1 = pair_info["token1"]
+    else:
+        tok_a = resolve_token(chain, token_a, rpc)
+        tok_b = resolve_token(chain, token_b, rpc)
+        token0, token1 = sort_token_addresses(tok_a["address"], tok_b["address"])
+
+    approval_status = check_v2_approvals(token0, token1, wallet_addr, chain_name, rpc)
+
+    # 3. Build add liquidity tx
+    add_result = build_add_liquidity_tx(
+        chain_name, token_a, token_b, amount_a, amount_b,
+        slippage=slippage, recipient=wallet_addr, rpc_url=rpc,
+    )
+
+    # 4. Build approval txs if needed
+    approval_txs = []
+    for label in ["token0", "token1"]:
+        tok_info = approval_status.get(label, {})
+        if tok_info.get("needsApproval"):
+            approval_txs.append(build_v2_approval_tx(tok_info["address"], wallet_addr, chain_name))
+
+    output = {
+        "action": "v2_add_liquidity_flow",
+        "pair": pair_info,
+        "approval": approval_status,
+        "addLiquidity": add_result,
+        "approvalTxs": approval_txs,
+        "nextActions": ([] if not approval_txs else ["broadcast-approvals"]) + ["broadcast-add-liquidity"],
+    }
+
+    dump_json(output)
+    if output_dir:
+        out_path = Path(output_dir)
+        out_path.mkdir(parents=True, exist_ok=True)
+        out_path.joinpath("v2_add_liquidity_flow.json").write_text(
+            json.dumps(output, ensure_ascii=False, indent=2) + "\n", encoding="utf-8"
+        )
+
+    return output
+
+
+def run_v2_remove_liquidity_flow(
+    chain_name: str,
+    token_a: str,
+    token_b: str,
+    liquidity_pct: float = 100.0,
+    slippage: float = 0.5,
+    wallet: str | None = None,
+    rpc_url: str | None = None,
+    output_dir: str | None = None,
+    broadcast_args: argparse.Namespace | None = None,
+) -> dict[str, Any]:
+    chain = normalize_chain(chain_name)
+    wallet_addr = resolve_wallet_address(wallet)
+    if not wallet_addr:
+        raise ValueError("wallet address required (--wallet or configure wallet env)")
+
+    rpc = rpc_url or resolve_rpc_url(None, chain.chain_id)[0]
+    if not rpc:
+        raise RuntimeError(f"RPC URL not configured for {chain_name}; set an RPC env var or pass --rpc-url")
+
+    # 1. Query pair info
+    pair_info = query_pair_full_info(chain_name, token_a, token_b, rpc)
+    if not pair_info.get("exists"):
+        raise ValueError(f"V2 pair {token_a}/{token_b} does not exist on {chain_name}")
+
+    pair_address = pair_info["pairAddress"]
+
+    # 2. Query LP balance
+    lp_balance = query_lp_balance(pair_address, wallet_addr, rpc)
+    if lp_balance == 0:
+        raise ValueError(f"No LP tokens for {token_a}/{token_b} in wallet {wallet_addr}")
+
+    # Calculate liquidity to remove based on percentage
+    from decimal import Decimal
+    liquidity_to_remove = str(int(Decimal(lp_balance) * Decimal(str(liquidity_pct)) / Decimal("100")))
+    if int(liquidity_to_remove) == 0:
+        raise ValueError("Calculated liquidity to remove is 0")
+
+    # 3. Build remove liquidity tx
+    remove_result = build_remove_liquidity_tx(
+        chain_name, token_a, token_b, liquidity_to_remove,
+        slippage=slippage, recipient=wallet_addr, rpc_url=rpc,
+    )
+
+    output = {
+        "action": "v2_remove_liquidity_flow",
+        "pair": pair_info,
+        "lpBalance": str(lp_balance),
+        "liquidityToRemove": liquidity_to_remove,
+        "removePct": liquidity_pct,
+        "removeLiquidity": remove_result,
+        "nextActions": ["broadcast-remove-liquidity"],
+    }
+
+    dump_json(output)
+    if output_dir:
+        out_path = Path(output_dir)
+        out_path.mkdir(parents=True, exist_ok=True)
+        out_path.joinpath("v2_remove_liquidity_flow.json").write_text(
+            json.dumps(output, ensure_ascii=False, indent=2) + "\n", encoding="utf-8"
+        )
+
+    return output
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description="Uniswap V2 LP 全流程编排")
+    sub = parser.add_subparsers(dest="command")
+
+    add = sub.add_parser("add", help="添加 V2 流动性")
+    add.add_argument("--chain", required=True, help="链名")
+    add.add_argument("--token-a", required=True, help="代币 A")
+    add.add_argument("--token-b", required=True, help="代币 B")
+    add.add_argument("--amount-a", required=True, help="代币 A 数量")
+    add.add_argument("--amount-b", required=True, help="代币 B 数量")
+    add.add_argument("--slippage", type=float, default=0.5, help="滑点百分比")
+    add.add_argument("--wallet", help="钱包地址")
+    add.add_argument("--rpc-url", help="RPC URL")
+    add.add_argument("--output-dir", help="输出目录")
+
+    remove = sub.add_parser("remove", help="移除 V2 流动性")
+    remove.add_argument("--chain", required=True, help="链名")
+    remove.add_argument("--token-a", required=True, help="代币 A")
+    remove.add_argument("--token-b", required=True, help="代币 B")
+    remove.add_argument("--liquidity-pct", type=float, default=100.0, help="移除百分比，默认 100%%")
+    remove.add_argument("--slippage", type=float, default=0.5, help="滑点百分比")
+    remove.add_argument("--wallet", help="钱包地址")
+    remove.add_argument("--rpc-url", help="RPC URL")
+    remove.add_argument("--output-dir", help="输出目录")
+
+    args = parser.parse_args()
+    load_local_env()
+
+    if args.command == "add":
+        run_v2_add_liquidity_flow(
+            args.chain, args.token_a, args.token_b,
+            args.amount_a, args.amount_b,
+            args.slippage, args.wallet, args.rpc_url, args.output_dir,
+        )
+    elif args.command == "remove":
+        run_v2_remove_liquidity_flow(
+            args.chain, args.token_a, args.token_b,
+            args.liquidity_pct, args.slippage,
+            args.wallet, args.rpc_url, args.output_dir,
+        )
+    else:
+        parser.print_help()
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

uniswap_autopilot/lp/v2/pair.py

@@ -0,0 +1,135 @@
+#!/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_v2_factory_address,
+    load_local_env,
+    normalize_chain,
+    resolve_token,
+    sort_token_addresses,
+)
+from uniswap_autopilot.execute._internal.rpc import (
+    decode_address, decode_uint, encode_address, encode_selector, eth_call, resolve_rpc_url,
+)
+
+ZERO_ADDR = "0x0000000000000000000000000000000000000000"
+
+
+def query_pair_address(token0: str, token1: str, factory: str, rpc_url: str) -> str:
+    sel = encode_selector("getPair(address,address)")
+    data = sel + encode_address(token0).replace("0x", "") + encode_address(token1).replace("0x", "")
+    raw = eth_call(factory, data, rpc_url)
+    addr = decode_address(raw)
+    if not addr or addr == ZERO_ADDR:
+        return ""
+    return addr
+
+
+
+def query_reserves(pair_address: str, rpc_url: str) -> dict[str, Any]:
+    sel = encode_selector("getReserves()")
+    raw = eth_call(pair_address, sel, rpc_url)
+    clean = raw.replace("0x", "")
+    if len(clean) < 128:
+        return {"reserve0": 0, "reserve1": 0}
+    reserve0 = decode_uint("0x" + clean[0:64])
+    reserve1 = decode_uint("0x" + clean[64:128])
+    return {"reserve0": reserve0, "reserve1": reserve1}
+
+
+def query_total_supply(pair_address: str, rpc_url: str) -> int:
+    sel = encode_selector("totalSupply()")
+    raw = eth_call(pair_address, sel, rpc_url)
+    return decode_uint(raw)
+
+
+def query_lp_balance(pair_address: str, owner: str, rpc_url: str) -> int:
+    sel = encode_selector("balanceOf(address)")
+    data = sel + encode_address(owner).replace("0x", "")
+    raw = eth_call(pair_address, data, rpc_url)
+    return decode_uint(raw)
+
+
+def query_pair_tokens(pair_address: str, rpc_url: str) -> tuple[str, str]:
+    sel0 = encode_selector("token0()")
+    raw0 = eth_call(pair_address, sel0, rpc_url)
+    token0 = decode_address(raw0)
+    sel1 = encode_selector("token1()")
+    raw1 = eth_call(pair_address, sel1, rpc_url)
+    token1 = decode_address(raw1)
+    return token0, token1
+
+
+def query_pair_full_info(
+    chain_name: str,
+    token_a: str,
+    token_b: str,
+    rpc_url: str | None = None,
+) -> dict[str, Any]:
+    chain = normalize_chain(chain_name)
+    rpc = rpc_url or resolve_rpc_url(None, chain.chain_id)[0]
+    if not rpc:
+        raise RuntimeError(f"RPC URL not configured for {chain_name}")
+
+    factory = get_v2_factory_address(chain_name)
+
+    tok_a = resolve_token(chain, token_a, rpc)
+    tok_b = resolve_token(chain, token_b, rpc)
+
+    token0, token1 = sort_token_addresses(tok_a["address"], tok_b["address"])
+
+    pair_address = query_pair_address(token0, token1, factory, rpc)
+    if not pair_address:
+        return {
+            "action": "v2_pair_info",
+            "chain": {"key": chain.key, "chainId": chain.chain_id},
+            "tokenA": tok_a,
+            "tokenB": tok_b,
+            "token0": token0,
+            "token1": token1,
+            "pairAddress": None,
+            "exists": False,
+        }
+
+    reserves = query_reserves(pair_address, rpc)
+    total_supply = query_total_supply(pair_address, rpc)
+
+    return {
+        "action": "v2_pair_info",
+        "chain": {"key": chain.key, "chainId": chain.chain_id},
+        "tokenA": tok_a,
+        "tokenB": tok_b,
+        "token0": token0,
+        "token1": token1,
+        "pairAddress": pair_address,
+        "exists": True,
+        "reserves": reserves,
+        "totalSupply": str(total_supply),
+    }
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description="查询 Uniswap V2 Pair 信息")
+    parser.add_argument("--chain", required=True, help="链名")
+    parser.add_argument("--token-a", required=True, help="代币 A symbol 或地址")
+    parser.add_argument("--token-b", required=True, help="代币 B symbol 或地址")
+    parser.add_argument("--rpc-url", help="RPC URL")
+    parser.add_argument("--output", help="输出 JSON 文件路径")
+    args = parser.parse_args()
+
+    load_local_env()
+    result = query_pair_full_info(args.chain, args.token_a, args.token_b, args.rpc_url)
+    dump_json(result)
+    if args.output:
+        Path(args.output).write_text(json.dumps(result, ensure_ascii=False, indent=2) + "\n", encoding="utf-8")
+
+
+if __name__ == "__main__":
+    main()