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

uniswap_autopilot/swap/trading_api/quote.py

@@ -0,0 +1,282 @@
+#!/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 (
+    add_common_arguments,
+    decimal_to_base_units,
+    dump_json,
+    load_local_env,
+    normalize_chain,
+    override_decimals,
+    parse_amount,
+    post_json,
+    require_api_key,
+    resolve_api_token,
+    resolve_token,
+    resolve_wallet_address,
+)
+
+
+def summarize_quote(raw_quote: dict[str, Any]) -> dict[str, Any]:
+    routing = raw_quote.get("routing")
+    quote = raw_quote.get("quote") or {}
+    summary: dict[str, Any] = {"routing": routing}
+    price_impact = quote.get("priceImpact")
+    if price_impact is not None:
+        summary["priceImpact"] = price_impact
+        try:
+            pi = float(price_impact)
+            if pi >= 10:
+                summary["priceImpactWarning"] = "EXTREME"
+            elif pi >= 5:
+                summary["priceImpactWarning"] = "HIGH"
+            elif pi >= 1:
+                summary["priceImpactWarning"] = "MODERATE"
+        except (ValueError, TypeError):
+            pass
+    if routing == "CLASSIC":
+        summary["outputAmount"] = ((quote.get("output") or {}).get("amount"))
+        summary["gasFee"] = quote.get("gasFee")
+        summary["gasFeeUSD"] = quote.get("gasFeeUSD")
+        summary["gasUseEstimate"] = quote.get("gasUseEstimate")
+        return summary
+
+    order_info = quote.get("orderInfo") or {}
+    outputs = order_info.get("outputs") or []
+    best_output = outputs[0].get("startAmount") if outputs else None
+    summary["bestOutputAmount"] = best_output
+    summary["deadline"] = order_info.get("deadline")
+    summary["chainId"] = order_info.get("chainId")
+    return summary
+
+
+def build_approval_payload(
+    wallet: str,
+    chain_id: int,
+    api_token_in: dict[str, Any],
+    base_amount: str,
+) -> dict[str, Any]:
+    return {
+        "walletAddress": wallet,
+        "token": api_token_in["address"],
+        "amount": base_amount,
+        "chainId": chain_id,
+    }
+
+
+def build_quote_payload(
+    wallet: str | None,
+    chain_id: int,
+    api_token_in: dict[str, Any],
+    api_token_out: dict[str, Any],
+    base_amount: str,
+    swap_type: str,
+    slippage: float,
+    routing_preference: str,
+    dst_chain_id: int | None = None,
+) -> dict[str, Any]:
+    return {
+        "swapper": wallet or "0x0000000000000000000000000000000000000001",
+        "tokenIn": api_token_in["address"],
+        "tokenOut": api_token_out["address"],
+        "tokenInChainId": chain_id,
+        "tokenOutChainId": dst_chain_id or chain_id,
+        "amount": base_amount,
+        "type": swap_type,
+        "slippageTolerance": slippage,
+        "routingPreference": routing_preference,
+    }
+
+
+def prepare_quote_request_data(
+    chain_name: str,
+    token_in_name: str,
+    token_out_name: str,
+    amount_value: str,
+    wallet: str | None = None,
+    token_in_decimals: int | None = None,
+    token_out_decimals: int | None = None,
+    swap_type: str = "EXACT_INPUT",
+    slippage: float = 0.5,
+    routing_preference: str = "BEST_PRICE",
+    check_approval: bool = False,
+    auto_slippage: bool = False,
+    dst_chain_name: str | None = None,
+) -> tuple[dict[str, Any], dict[str, Any] | None, dict[str, Any]]:
+    chain = normalize_chain(chain_name)
+    amount = parse_amount(amount_value)
+    token_in = override_decimals(resolve_token(chain, token_in_name), token_in_decimals)
+
+    if dst_chain_name:
+        dst_chain = normalize_chain(dst_chain_name)
+        token_out = override_decimals(resolve_token(dst_chain, token_out_name), token_out_decimals)
+    else:
+        dst_chain = chain
+        token_out = override_decimals(resolve_token(chain, token_out_name), token_out_decimals)
+
+    api_token_in = resolve_api_token(chain, token_in)
+    api_token_out = resolve_api_token(dst_chain, token_out)
+    validated_wallet = resolve_wallet_address(wallet, "wallet")
+
+    if check_approval and not validated_wallet:
+        raise ValueError("--check-approval requires --wallet or a wallet address env var")
+    if slippage < 0 or slippage > 100:
+        raise ValueError("--slippage must be between 0 and 100")
+
+    effective_slippage = slippage
+    slippage_source = "manual"
+    if auto_slippage:
+        from uniswap_autopilot.swap.extensions.slippage import suggest_slippage
+        suggestion = suggest_slippage(chain_name, token_in_name, token_out_name, float(amount))
+        effective_slippage = suggestion["recommendedSlippage"]
+        slippage_source = f"auto({suggestion['category']})"
+
+    base_amount = decimal_to_base_units(amount, api_token_in["decimals"])
+    response: dict[str, Any] = {
+        "action": "trading_api_quote",
+        "chain": {"key": chain.key, "chainId": chain.chain_id},
+        "tokenIn": token_in,
+        "tokenOut": token_out,
+        "apiTokenIn": api_token_in,
+        "apiTokenOut": api_token_out,
+        "wallet": validated_wallet,
+        "humanAmount": format(amount, "f"),
+        "baseAmount": base_amount,
+        "slippage": effective_slippage,
+        "slippageSource": slippage_source,
+    }
+    if dst_chain_name:
+        response["dstChain"] = {"key": dst_chain.key, "chainId": dst_chain.chain_id}
+        response["crossChain"] = True
+
+    approval_payload: dict[str, Any] | None = None
+    if check_approval:
+        if token_in["address"] == "NATIVE":
+            response["approvalCheck"] = {
+                "skipped": True,
+                "reason": "token_in is native, approval is not required",
+            }
+        else:
+            approval_payload = build_approval_payload(
+                wallet=validated_wallet,
+                chain_id=chain.chain_id,
+                api_token_in=api_token_in,
+                base_amount=base_amount,
+            )
+
+    quote_payload = build_quote_payload(
+        wallet=validated_wallet,
+        chain_id=chain.chain_id,
+        api_token_in=api_token_in,
+        api_token_out=api_token_out,
+        base_amount=base_amount,
+        swap_type=swap_type,
+        slippage=effective_slippage,
+        routing_preference=routing_preference,
+        dst_chain_id=dst_chain.chain_id if dst_chain_name else None,
+    )
+    return response, approval_payload, quote_payload
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description="调用 Uniswap Trading API 做 quote / approval dry-run")
+    add_common_arguments(parser)
+    parser.add_argument(
+        "--wallet",
+        help="用户钱包地址。check-approval 必填；若未提供，则优先回退到 SECURE_WALLET_ADDRESS / HOT_WALLET_ADDRESS",
+    )
+    parser.add_argument(
+        "--swap-type",
+        choices=["EXACT_INPUT", "EXACT_OUTPUT"],
+        default="EXACT_INPUT",
+        help="Trading API quote type",
+    )
+    parser.add_argument(
+        "--slippage",
+        type=float,
+        default=0.5,
+        help="滑点百分比，默认 0.5",
+    )
+    parser.add_argument(
+        "--routing-preference",
+        default="BEST_PRICE",
+        help="如 BEST_PRICE / FASTEST / CLASSIC",
+    )
+    parser.add_argument(
+        "--auto-slippage",
+        action="store_true",
+        help="Automatically suggest slippage based on token pair and liquidity",
+    )
+    parser.add_argument(
+        "--dst-chain",
+        help="Destination chain for cross-chain swap (bridge)",
+    )
+    parser.add_argument(
+        "--check-approval",
+        action="store_true",
+        help="先调用 /check_approval",
+    )
+    parser.add_argument(
+        "--request-only",
+        action="store_true",
+        help="只打印将发送的请求 payload，不实际调用 Trading API",
+    )
+    parser.add_argument("--output", help="把完整 JSON 输出写入文件")
+    args = parser.parse_args()
+
+    try:
+        load_local_env()
+        response, approval_payload, quote_payload = prepare_quote_request_data(
+            chain_name=args.chain,
+            token_in_name=args.token_in,
+            token_out_name=args.token_out,
+            amount_value=args.amount,
+            wallet=args.wallet,
+            token_in_decimals=args.token_in_decimals,
+            token_out_decimals=args.token_out_decimals,
+            swap_type=args.swap_type,
+            slippage=args.slippage,
+            routing_preference=args.routing_preference,
+            check_approval=args.check_approval,
+            auto_slippage=args.auto_slippage,
+            dst_chain_name=args.dst_chain,
+        )
+        response["requestOnly"] = args.request_only
+        response["requestPayloads"] = {
+            "checkApproval": approval_payload,
+            "quote": quote_payload,
+        }
+
+        if not args.request_only:
+            api_key = require_api_key()
+            if approval_payload is not None:
+                response["approvalCheck"] = post_json("check_approval", approval_payload, api_key)
+            raw_quote = post_json("quote", quote_payload, api_key)
+            response["quoteSummary"] = summarize_quote(raw_quote)
+            pi_warning = (response["quoteSummary"] or {}).get("priceImpactWarning")
+            if pi_warning:
+                pi_val = response["quoteSummary"].get("priceImpact", "?")
+                print(f"WARNING: price impact {pi_val}% ({pi_warning})", file=sys.stderr)
+            response["rawQuote"] = raw_quote
+
+        if args.output:
+            Path(args.output).write_text(
+                json.dumps(response, ensure_ascii=False, indent=2) + "\n",
+                encoding="utf-8",
+            )
+
+        dump_json(response)
+    except Exception as exc:  # noqa: BLE001 - CLI should return readable errors
+        print(json.dumps({"error": str(exc)}, ensure_ascii=False, indent=2), file=sys.stderr)
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

uniswap_autopilot/swap/trading_api/swap.py

@@ -0,0 +1,248 @@
+#!/usr/bin/env python3
+from __future__ import annotations
+
+import argparse
+import json
+import re
+import sys
+from pathlib import Path
+from typing import Any
+
+
+from uniswap_autopilot.common.common import dump_json, load_local_env, post_json, require_api_key
+
+UNISWAPX_ROUTINGS = {"DUTCH_V2", "DUTCH_V3", "PRIORITY"}
+HEX_RE = re.compile(r"^0x[0-9a-fA-F]+$")
+DOMAIN_FIELD_TYPES = {
+    "name": "string",
+    "version": "string",
+    "chainId": "uint256",
+    "verifyingContract": "address",
+    "salt": "bytes32",
+}
+
+
+def load_quote_payload(path: str) -> dict[str, Any]:
+    data = json.loads(Path(path).read_text(encoding="utf-8"))
+    raw_quote = data.get("rawQuote")
+    if not raw_quote:
+        raise ValueError("quote file must contain rawQuote from trading_api_quote.py")
+    quote = raw_quote.get("quote")
+    if not quote:
+        raise ValueError("rawQuote.quote is missing")
+    return data
+
+
+def is_uniswapx_route(raw_quote: dict[str, Any]) -> bool:
+    return str(raw_quote.get("routing") or "") in UNISWAPX_ROUTINGS
+
+
+def infer_primary_type(types: dict[str, Any]) -> str:
+    if not types:
+        raise ValueError("permitData.types is missing")
+
+    referenced: set[str] = set()
+    for fields in types.values():
+        for field in fields or []:
+            field_type = field.get("type")
+            if isinstance(field_type, str) and field_type in types:
+                referenced.add(field_type)
+
+    candidates = [type_name for type_name in types if type_name not in referenced]
+    if len(candidates) == 1:
+        return candidates[0]
+    if "PermitSingle" in types:
+        return "PermitSingle"
+    raise ValueError("could not infer primaryType from permitData.types")
+
+
+def build_eip712_domain_types(domain: dict[str, Any]) -> list[dict[str, str]]:
+    fields: list[dict[str, str]] = []
+    for name in domain:
+        field_type = DOMAIN_FIELD_TYPES.get(name)
+        if not field_type:
+            raise ValueError(f"unsupported EIP-712 domain field: {name}")
+        fields.append({"name": name, "type": field_type})
+    return fields
+
+
+def normalize_permit_typed_data(permit_data: dict[str, Any]) -> dict[str, Any]:
+    domain = permit_data.get("domain")
+    types = permit_data.get("types")
+    values = permit_data.get("values")
+    if not isinstance(domain, dict) or not isinstance(types, dict) or not isinstance(values, dict):
+        raise ValueError("permitData must contain domain, types, and values")
+
+    normalized_types = {type_name: fields for type_name, fields in types.items()}
+    if "EIP712Domain" not in normalized_types:
+        normalized_types["EIP712Domain"] = build_eip712_domain_types(domain)
+
+    return {
+        "types": normalized_types,
+        "primaryType": infer_primary_type(types),
+        "domain": domain,
+        "message": values,
+    }
+
+
+def validate_signature(signature: str) -> str:
+    cleaned = signature.strip()
+    if not HEX_RE.fullmatch(cleaned):
+        raise ValueError("signature must be a 0x-prefixed hex string")
+    return cleaned
+
+
+def load_signature_value(signature: str | None = None, signature_file: str | None = None) -> str | None:
+    if signature and signature_file:
+        raise ValueError("use only one of --signature or --signature-file")
+    if signature:
+        return validate_signature(signature)
+    if not signature_file:
+        return None
+
+    raw = Path(signature_file).read_text(encoding="utf-8").strip()
+    if not raw:
+        raise ValueError("signature file is empty")
+    if raw.startswith("{"):
+        blob = json.loads(raw)
+        value = blob.get("signature")
+        if not isinstance(value, str):
+            raise ValueError("signature json file must contain a string 'signature' field")
+        return validate_signature(value)
+    return validate_signature(raw)
+
+
+def build_permit_handoff(
+    raw_quote: dict[str, Any],
+    quote_file: str | None = None,
+) -> dict[str, Any]:
+    permit_data = raw_quote.get("permitData")
+    if not permit_data:
+        raise ValueError("quote does not contain permitData")
+
+    routing = str(raw_quote.get("routing") or "UNKNOWN")
+    uniswapx = is_uniswapx_route(raw_quote)
+    typed_data = normalize_permit_typed_data(permit_data)
+    handoff = {
+        "routing": routing,
+        "quoteFile": quote_file,
+        "signatureRule": {
+            "signPermitDataLocally": True,
+            "sendSignatureToSwap": True,
+            "sendPermitDataToSwap": not uniswapx,
+        },
+        "permitData": permit_data,
+        "typedData": typed_data,
+        "instructions": [
+            "Use typedData as the canonical EIP-712 JSON for wallet signing.",
+            "Save the resulting 0x signature into a text file or a JSON file with a 'signature' field.",
+            "Pass that file to swap_dry_run.py via --signature-file to continue /swap.",
+        ],
+    }
+    return handoff
+
+
+def build_swap_payload(
+    raw_quote: dict[str, Any],
+    signature: str | None = None,
+    simulate_transaction: bool = False,
+    refresh_gas_price: bool = False,
+) -> dict[str, Any]:
+    quote = raw_quote.get("quote")
+    if not quote:
+        raise ValueError("rawQuote.quote is missing")
+
+    permit_data = raw_quote.get("permitData")
+    if permit_data and not signature:
+        raise ValueError("quote 返回了 permitData，调用 /swap 前必须提供 --signature")
+    if signature and not permit_data:
+        raise ValueError("quote 未返回 permitData，不应传入 --signature")
+
+    payload: dict[str, Any] = {
+        "quote": quote,
+        "refreshGasPrice": refresh_gas_price,
+        "simulateTransaction": simulate_transaction,
+    }
+    if permit_data:
+        payload["signature"] = signature
+        if not is_uniswapx_route(raw_quote):
+            payload["permitData"] = permit_data
+    return payload
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description="基于 quote 结果调用 /swap 做 dry-run")
+    parser.add_argument("--quote-file", required=True, help="trading_api_quote.py 输出的 JSON 文件路径")
+    parser.add_argument("--signature", help="当 quote 返回 permitData 时，传入签名")
+    parser.add_argument("--signature-file", help="从文件读取签名；支持纯文本 0x... 或 JSON {'signature': '0x...'}")
+    parser.add_argument("--permit-output", help="仅导出 permitData handoff JSON，不调用 /swap")
+    parser.add_argument("--typed-data-output", help="导出标准 EIP-712 typed data JSON，便于 cast/钱包签名")
+    parser.add_argument(
+        "--simulate-transaction",
+        action="store_true",
+        help="让 /swap 在服务端做 simulateTransaction",
+    )
+    parser.add_argument(
+        "--refresh-gas-price",
+        action="store_true",
+        help="让 /swap 重新抓 gas price",
+    )
+    parser.add_argument(
+        "--request-only",
+        action="store_true",
+        help="只打印将发送的 /swap body，不实际调用",
+    )
+    parser.add_argument("--output", help="把完整 JSON 输出写入文件")
+    args = parser.parse_args()
+
+    try:
+        load_local_env()
+        quote_blob = load_quote_payload(args.quote_file)
+        raw_quote = quote_blob["rawQuote"]
+        if args.permit_output or args.typed_data_output:
+            handoff = build_permit_handoff(raw_quote=raw_quote, quote_file=args.quote_file)
+            if args.permit_output:
+                Path(args.permit_output).write_text(
+                    json.dumps(handoff, ensure_ascii=False, indent=2) + "\n",
+                    encoding="utf-8",
+                )
+            if args.typed_data_output:
+                Path(args.typed_data_output).write_text(
+                    json.dumps(handoff["typedData"], ensure_ascii=False, indent=2) + "\n",
+                    encoding="utf-8",
+                )
+            dump_json(handoff if args.permit_output else handoff["typedData"])
+            return
+
+        signature = load_signature_value(args.signature, args.signature_file)
+        payload = build_swap_payload(
+            raw_quote=raw_quote,
+            signature=signature,
+            simulate_transaction=args.simulate_transaction,
+            refresh_gas_price=args.refresh_gas_price,
+        )
+
+        response: dict[str, Any] = {
+            "action": "swap_dry_run",
+            "requestOnly": args.request_only,
+            "requestPayload": payload,
+        }
+
+        if not args.request_only:
+            api_key = require_api_key()
+            response["swapResponse"] = post_json("swap", payload, api_key)
+
+        if args.output:
+            Path(args.output).write_text(
+                json.dumps(response, ensure_ascii=False, indent=2) + "\n",
+                encoding="utf-8",
+            )
+
+        dump_json(response)
+    except Exception as exc:  # noqa: BLE001
+        print(json.dumps({"error": str(exc)}, ensure_ascii=False, indent=2), file=sys.stderr)
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()