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

uniswap_autopilot/swap/flow_core/__init__.py

@@ -0,0 +1,2 @@
+"""Internal helpers for the swap trade-flow runner."""
+

uniswap_autopilot/swap/flow_core/artifacts.py

@@ -0,0 +1,11 @@
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import Any
+
+
+def write_json(path: Path, payload: dict[str, Any]) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(json.dumps(payload, ensure_ascii=False, indent=2) + "\n", encoding="utf-8")
+

uniswap_autopilot/swap/flow_core/broadcast.py

@@ -0,0 +1,50 @@
+from __future__ import annotations
+
+import argparse
+from typing import Any
+
+from uniswap_autopilot.execute import broadcast as execute_transaction
+
+
+def maybe_broadcast(
+    tx: dict[str, Any],
+    explicit_rpc_url: str | None,
+    confirm: str | None,
+    signer_args_source: argparse.Namespace,
+    receipt_confirmations: int,
+    use_flashbots: bool = False,
+) -> dict[str, Any]:
+    broadcast = execute_transaction.broadcast_with_backend(
+        tx=tx,
+        explicit_rpc_url=explicit_rpc_url,
+        confirm=confirm,
+        signer_args_source=signer_args_source,
+        use_flashbots=use_flashbots,
+    )
+    preflight = execute_transaction.build_preflight_report(
+        tx=tx,
+        explicit_rpc_url=broadcast["rpcUrl"],
+        strict=True,
+    )
+    if not preflight.get("ok"):
+        raise RuntimeError("broadcast preflight failed: " + "; ".join(preflight.get("issues") or []))
+    broadcast_result = broadcast["broadcastResult"]
+    transaction_hash = execute_transaction.extract_transaction_hash(broadcast_result)
+    receipt = execute_transaction.execute_cast_receipt(
+        tx_hash=transaction_hash,
+        rpc_url=broadcast["rpcUrl"],
+        confirmations=receipt_confirmations,
+    )
+    if not execute_transaction.receipt_succeeded(receipt):
+        raise RuntimeError(f"broadcast receipt status is not successful: {receipt.get('status')}")
+    response = {
+        "commandPreview": broadcast["commandPreview"],
+        "preflight": preflight,
+        "broadcastResult": broadcast_result,
+        "transactionHash": transaction_hash,
+        "receipt": receipt,
+        "signerBackend": broadcast["signerBackend"],
+    }
+    if broadcast.get("serviceDecision") is not None:
+        response["serviceDecision"] = broadcast["serviceDecision"]
+    return response

uniswap_autopilot/swap/flow_core/diagnostics.py

@@ -0,0 +1,216 @@
+from __future__ import annotations
+
+from pathlib import Path
+import time
+from typing import Any
+
+from uniswap_autopilot.common.common import normalize_chain
+from uniswap_autopilot.execute import broadcast as execute_transaction
+
+NATIVE_CURRENCY_ADDRESS = "0x0000000000000000000000000000000000000000"
+STALE_QUOTE_SECONDS = 600
+
+
+def append_unique(items: list[str], value: str) -> None:
+    if value and value not in items:
+        items.append(value)
+
+
+def parse_intish(value: Any) -> int | None:
+    if value is None:
+        return None
+    if isinstance(value, int):
+        return value
+    if isinstance(value, str):
+        cleaned = value.strip()
+        if not cleaned:
+            return None
+        base = 16 if cleaned.lower().startswith("0x") else 10
+        return int(cleaned, base)
+    return int(value)
+
+
+def extract_permit_sig_deadline(raw_quote: dict[str, Any]) -> int | None:
+    permit_values = (raw_quote.get("permitData") or {}).get("values") or {}
+    return parse_intish(permit_values.get("sigDeadline"))
+
+
+def quote_age_seconds(path: Path) -> int | None:
+    if not path.exists():
+        return None
+    return max(0, int(time.time() - path.stat().st_mtime))
+
+
+def classify_swap_failure(
+    *,
+    error_text: str,
+    raw_quote: dict[str, Any],
+    wallet: str,
+    chain_name: str,
+    explicit_rpc_url: str | None,
+    quote_path: Path,
+    reused_saved_quote: bool,
+    has_signature: bool,
+    approval_required: bool,
+    assume_approval_ready: bool,
+) -> dict[str, Any]:
+    error_lower = error_text.lower()
+    category = "swap_request_failed"
+    if "transfer_from_failed" in error_lower:
+        category = "transfer_from_failed"
+    elif "failed_to_estimate_gas" in error_lower or "execution reverted" in error_lower:
+        category = "simulation_reverted"
+
+    issues: list[str] = []
+    next_actions: list[str] = []
+    checks: dict[str, Any] = {}
+
+    now = int(time.time())
+    sig_deadline = extract_permit_sig_deadline(raw_quote)
+    if sig_deadline is not None:
+        checks["permitSigDeadline"] = sig_deadline
+        checks["permitSigDeadlineExpired"] = sig_deadline <= now
+        if sig_deadline <= now:
+            category = "permit_signature_expired"
+            append_unique(issues, "permitData.sigDeadline has passed")
+            append_unique(next_actions, "refresh-quote")
+            append_unique(next_actions, "re-sign-permit")
+
+    if reused_saved_quote:
+        age = quote_age_seconds(quote_path)
+        checks["quoteAgeSeconds"] = age
+        if age is not None and age > STALE_QUOTE_SECONDS:
+            append_unique(issues, f"reused quote is stale ({age}s old)")
+            append_unique(next_actions, "refresh-quote")
+            if has_signature:
+                append_unique(next_actions, "re-sign-permit")
+
+    chain = normalize_chain(chain_name)
+    rpc_url, rpc_candidates = execute_transaction.resolve_rpc_url(explicit_rpc_url, chain.chain_id)
+    checks["rpcUrlResolved"] = rpc_url
+    checks["rpcEnvCandidates"] = rpc_candidates
+    if not rpc_url:
+        append_unique(issues, "RPC URL is not configured, cannot verify balance/allowance diagnostics")
+        return {
+            "category": category,
+            "issues": issues,
+            "nextActions": next_actions,
+            "checks": checks,
+        }
+
+    quote_blob = raw_quote.get("quote") or {}
+    quote_input = quote_blob.get("input") or {}
+    input_token = str(quote_input.get("token") or "")
+    input_amount = parse_intish(quote_input.get("amount"))
+    gas_fee = parse_intish(quote_blob.get("gasFee")) or 0
+    checks["inputToken"] = input_token
+    checks["inputAmount"] = str(input_amount) if input_amount is not None else None
+    checks["gasFeeFromQuote"] = str(gas_fee)
+
+    try:
+        native_balance = execute_transaction.query_native_balance(wallet, rpc_url)
+        checks["nativeBalance"] = str(native_balance)
+        if native_balance < gas_fee:
+            if category not in {"insufficient_input_balance"}:
+                category = "insufficient_native_gas"
+            append_unique(issues, f"native balance {native_balance} is below quoted gas fee {gas_fee}")
+            append_unique(next_actions, "top-up-native-gas")
+    except Exception as exc:  # noqa: BLE001
+        append_unique(issues, f"failed to query native balance: {exc}")
+        return {
+            "category": category,
+            "issues": issues,
+            "nextActions": next_actions,
+            "checks": checks,
+        }
+
+    if input_amount is None:
+        append_unique(issues, "quote.input.amount is missing")
+        return {
+            "category": category,
+            "issues": issues,
+            "nextActions": next_actions,
+            "checks": checks,
+        }
+
+    if input_token.lower() == NATIVE_CURRENCY_ADDRESS:
+        required_native = input_amount + gas_fee
+        checks["requiredNativeForInputAndGas"] = str(required_native)
+        if native_balance < required_native:
+            category = "insufficient_input_balance"
+            append_unique(
+                issues,
+                f"native balance {native_balance} is below required {required_native} (input + gas)",
+            )
+            append_unique(next_actions, "top-up-input-token")
+            append_unique(next_actions, "reduce-amount")
+        return {
+            "category": category,
+            "issues": issues,
+            "nextActions": next_actions,
+            "checks": checks,
+        }
+
+    try:
+        token_balance = execute_transaction.query_erc20_balance(wallet, input_token, rpc_url)
+        checks["inputTokenBalance"] = str(token_balance)
+        if token_balance < input_amount:
+            category = "insufficient_input_balance"
+            append_unique(issues, f"token balance {token_balance} is below required input {input_amount}")
+            append_unique(next_actions, "top-up-input-token")
+            append_unique(next_actions, "reduce-amount")
+    except Exception as exc:  # noqa: BLE001
+        append_unique(issues, f"failed to query token balance: {exc}")
+        return {
+            "category": category,
+            "issues": issues,
+            "nextActions": next_actions,
+            "checks": checks,
+        }
+
+    permit_verifier = ((raw_quote.get("permitData") or {}).get("domain") or {}).get("verifyingContract")
+    if permit_verifier:
+        try:
+            allowance = execute_transaction.query_erc20_allowance(input_token, wallet, permit_verifier, rpc_url)
+            checks["permitAllowance"] = {
+                "spender": permit_verifier.lower(),
+                "current": str(allowance),
+                "required": str(input_amount),
+                "sufficient": allowance >= input_amount,
+            }
+            if allowance < input_amount:
+                category = "insufficient_allowance"
+                append_unique(
+                    issues,
+                    f"allowance {allowance} is below required input {input_amount} for {permit_verifier.lower()}",
+                )
+                if approval_required and not assume_approval_ready:
+                    append_unique(next_actions, "broadcast-approval")
+                else:
+                    append_unique(next_actions, "refresh-quote")
+                    if has_signature:
+                        append_unique(next_actions, "re-sign-permit")
+        except Exception as exc:  # noqa: BLE001
+            append_unique(issues, f"failed to query permit allowance: {exc}")
+
+    return {
+        "category": category,
+        "issues": issues,
+        "nextActions": next_actions,
+        "checks": checks,
+    }
+
+
+def build_swap_failure_message(error_text: str, diagnosis: dict[str, Any]) -> str:
+    parts = [f"swap dry-run failed ({diagnosis.get('category')})"]
+    issues = diagnosis.get("issues") or []
+    if issues:
+        parts.append("issues: " + "; ".join(issues))
+    actions = diagnosis.get("nextActions") or []
+    if actions:
+        parts.append("next: " + ", ".join(actions))
+    headline = error_text.splitlines()[0].strip()
+    if len(headline) > 220:
+        headline = headline[:220] + "..."
+    parts.append(f"upstream: {headline}")
+    return " | ".join(parts)

uniswap_autopilot/swap/flow_core/paper.py

@@ -0,0 +1,113 @@
+from __future__ import annotations
+
+from datetime import datetime, timezone
+import json
+from pathlib import Path
+from typing import Any
+from uuid import uuid4
+
+from uniswap_autopilot.swap.trading_api import quote as trading_api_quote
+
+
+def append_jsonl(path: Path, payload: dict[str, Any]) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    with path.open("a", encoding="utf-8") as handle:
+        handle.write(json.dumps(payload, ensure_ascii=False) + "\n")
+
+
+def build_paper_trade_entry_id() -> str:
+    timestamp = datetime.now(timezone.utc).strftime("%Y%m%dT%H%M%SZ")
+    return f"{timestamp}-{uuid4().hex[:8]}"
+
+
+def build_paper_trade_paths(output_dir: str, journal_file: str | None) -> tuple[str, Path, Path]:
+    entry_id = build_paper_trade_entry_id()
+    output_root = Path(output_dir)
+    run_output_dir = output_root / "runs" / entry_id
+    journal_path = Path(journal_file) if journal_file else output_root / "paper-trade-journal.jsonl"
+    return entry_id, run_output_dir, journal_path
+
+
+def build_paper_trade_info(
+    *,
+    entry_id: str,
+    journal_path: Path,
+    run_output_dir: Path,
+    status: str,
+    response: dict[str, Any] | None,
+    error: str | None = None,
+) -> dict[str, Any]:
+    swap = (response or {}).get("swap") or {}
+    info: dict[str, Any] = {
+        "enabled": True,
+        "status": status,
+        "entryId": entry_id,
+        "journalFile": str(journal_path),
+        "runOutputDir": str(run_output_dir),
+        "recordedAt": datetime.now(timezone.utc).isoformat(),
+        "swapPreviewSource": "quote-only" if swap.get("quoteOnly") else "swap-response",
+    }
+    if error is not None:
+        info["error"] = error
+    return info
+
+
+def build_paper_trade_journal_entry(
+    *,
+    entry_id: str,
+    journal_status: str,
+    run_output_dir: Path,
+    request_context: dict[str, Any],
+    response: dict[str, Any] | None,
+    error: str | None = None,
+) -> dict[str, Any]:
+    entry: dict[str, Any] = {
+        "entryId": entry_id,
+        "recordedAt": datetime.now(timezone.utc).isoformat(),
+        "mode": "paper-trade",
+        "status": journal_status,
+        "runOutputDir": str(run_output_dir),
+        "requestedTrade": request_context,
+    }
+    payload = response or {}
+    for field in (
+        "action",
+        "inputs",
+        "files",
+        "quote",
+        "automation",
+        "policyCheck",
+        "approval",
+        "permit",
+        "swap",
+        "swapFailureDiagnosis",
+        "nextActions",
+    ):
+        if field in payload:
+            entry[field] = payload[field]
+    if error is not None:
+        entry["error"] = error
+    return entry
+
+
+def build_quote_only_paper_swap(raw_quote: dict[str, Any], reason: str) -> dict[str, Any]:
+    quote = raw_quote.get("quote") or {}
+    return {
+        "paperOnly": True,
+        "quoteOnly": True,
+        "paperOnlyReason": reason,
+        "simulationRequested": False,
+        "simulationUsed": False,
+        "simulationFallbackReason": None,
+        "broadcastRequested": False,
+        "autoBroadcast": False,
+        "quoteSummary": trading_api_quote.summarize_quote(raw_quote),
+        "quoteGasFee": quote.get("gasFee"),
+        "quoteGasFeeUSD": quote.get("gasFeeUSD"),
+        "quoteGasUseEstimate": quote.get("gasUseEstimate"),
+        "preflight": {
+            "checked": False,
+            "ok": None,
+            "reason": reason,
+        },
+    }

uniswap_autopilot/swap/flow_core/policy.py

@@ -0,0 +1,142 @@
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import Any
+
+from uniswap_autopilot.common.common import normalize_chain, parse_amount, resolve_token
+
+
+def normalize_policy_token(chain_name: str, token_name: str) -> str:
+    chain = normalize_chain(chain_name)
+    token = resolve_token(chain, token_name)
+    if token["address"] == "NATIVE":
+        return "NATIVE"
+    return str(token["address"]).lower()
+
+
+def load_auto_trade_policy(path: str) -> dict[str, Any]:
+    blob = json.loads(Path(path).read_text(encoding="utf-8"))
+    if not isinstance(blob, dict):
+        raise ValueError("auto-trade policy must be a JSON object")
+
+    enabled = blob.get("enabled")
+    if not isinstance(enabled, bool):
+        raise ValueError("auto-trade policy.enabled must be a boolean")
+
+    allowed_chains_raw = blob.get("allowedChains") or []
+    if not isinstance(allowed_chains_raw, list) or not all(isinstance(item, str) for item in allowed_chains_raw):
+        raise ValueError("auto-trade policy.allowedChains must be a string array")
+    allowed_chains = [normalize_chain(item).key for item in allowed_chains_raw]
+
+    allowed_pairs_raw = blob.get("allowedPairs")
+    if not isinstance(allowed_pairs_raw, list) or not allowed_pairs_raw:
+        raise ValueError("auto-trade policy.allowedPairs must be a non-empty array")
+
+    allowed_pairs: list[dict[str, Any]] = []
+    for index, raw_rule in enumerate(allowed_pairs_raw):
+        if not isinstance(raw_rule, dict):
+            raise ValueError(f"auto-trade policy.allowedPairs[{index}] must be an object")
+        chain_name = raw_rule.get("chain")
+        token_in = raw_rule.get("tokenIn")
+        token_out = raw_rule.get("tokenOut")
+        if not all(isinstance(value, str) and value.strip() for value in (chain_name, token_in, token_out)):
+            raise ValueError(
+                f"auto-trade policy.allowedPairs[{index}] must include non-empty chain/tokenIn/tokenOut"
+            )
+        normalized_chain = normalize_chain(chain_name).key
+        normalized_rule = {
+            "chain": normalized_chain,
+            "tokenIn": normalize_policy_token(normalized_chain, token_in),
+            "tokenOut": normalize_policy_token(normalized_chain, token_out),
+            "tokenInLabel": token_in,
+            "tokenOutLabel": token_out,
+            "allowAutoSignPermit": bool(raw_rule.get("allowAutoSignPermit", False)),
+            "allowAutoApproval": bool(raw_rule.get("allowAutoApproval", False)),
+            "allowAutoBroadcastSwap": bool(raw_rule.get("allowAutoBroadcastSwap", False)),
+        }
+        if "maxAmount" in raw_rule:
+            if not isinstance(raw_rule["maxAmount"], str):
+                raise ValueError(f"auto-trade policy.allowedPairs[{index}].maxAmount must be a string")
+            normalized_rule["maxAmount"] = str(parse_amount(raw_rule["maxAmount"]))
+        if "maxSlippage" in raw_rule:
+            max_slippage = raw_rule["maxSlippage"]
+            if not isinstance(max_slippage, (int, float)):
+                raise ValueError(f"auto-trade policy.allowedPairs[{index}].maxSlippage must be numeric")
+            if max_slippage < 0 or max_slippage > 100:
+                raise ValueError(f"auto-trade policy.allowedPairs[{index}].maxSlippage must be between 0 and 100")
+            normalized_rule["maxSlippage"] = float(max_slippage)
+        allowed_pairs.append(normalized_rule)
+
+    require_preflight_ok = blob.get("requirePreflightOk", True)
+    if not isinstance(require_preflight_ok, bool):
+        raise ValueError("auto-trade policy.requirePreflightOk must be a boolean")
+
+    return {
+        "enabled": enabled,
+        "allowedChains": allowed_chains,
+        "allowedPairs": allowed_pairs,
+        "requirePreflightOk": require_preflight_ok,
+        "sourceFile": path,
+    }
+
+
+def evaluate_auto_trade_policy(
+    policy: dict[str, Any],
+    chain_name: str,
+    token_in_name: str,
+    token_out_name: str,
+    amount_value: str,
+    slippage: float,
+) -> dict[str, Any]:
+    chain_key = normalize_chain(chain_name).key
+    requested_token_in = normalize_policy_token(chain_key, token_in_name)
+    requested_token_out = normalize_policy_token(chain_key, token_out_name)
+    requested_amount = parse_amount(amount_value)
+
+    issues: list[str] = []
+    matched_rule: dict[str, Any] | None = None
+
+    if not policy["enabled"]:
+        issues.append("policy is disabled")
+
+    if policy["allowedChains"] and chain_key not in policy["allowedChains"]:
+        issues.append(f"chain '{chain_key}' is not allowed")
+
+    for rule in policy["allowedPairs"]:
+        if (
+            rule["chain"] == chain_key
+            and rule["tokenIn"] == requested_token_in
+            and rule["tokenOut"] == requested_token_out
+        ):
+            matched_rule = rule
+            break
+    if matched_rule is None:
+        issues.append("token pair is not allowed")
+    else:
+        if "maxAmount" in matched_rule and requested_amount > parse_amount(matched_rule["maxAmount"]):
+            issues.append(
+                f"amount {format(requested_amount, 'f')} exceeds maxAmount {matched_rule['maxAmount']}"
+            )
+        if "maxSlippage" in matched_rule and slippage > float(matched_rule["maxSlippage"]):
+            issues.append(
+                f"slippage {slippage} exceeds maxSlippage {matched_rule['maxSlippage']}"
+            )
+
+    return {
+        "policyFile": policy["sourceFile"],
+        "allowed": len(issues) == 0,
+        "chain": chain_key,
+        "tokenIn": requested_token_in,
+        "tokenOut": requested_token_out,
+        "amount": format(requested_amount, "f"),
+        "slippage": slippage,
+        "requirePreflightOk": policy["requirePreflightOk"],
+        "matchedRule": matched_rule,
+        "issues": issues,
+    }
+
+
+def policy_rule_allows(policy_check: dict[str, Any] | None, field_name: str) -> bool:
+    return bool((policy_check or {}).get("matchedRule", {}).get(field_name))
+

uniswap_autopilot/swap/links/__init__.py

@@ -0,0 +1,2 @@
+"""Deep-link helpers for swap entry points."""
+

uniswap_autopilot/swap/links/deep_link.py

@@ -0,0 +1,69 @@
+#!/usr/bin/env python3
+from __future__ import annotations
+
+import argparse
+
+
+from uniswap_autopilot.common.common import (
+    add_common_arguments,
+    build_swap_link,
+    dump_json,
+    normalize_chain,
+    override_decimals,
+    parse_amount,
+    resolve_token,
+)
+
+
+def build_swap_link_response(
+    chain_name: str,
+    token_in_name: str,
+    token_out_name: str,
+    amount_value: str,
+    field: str = "INPUT",
+    token_in_decimals: int | None = None,
+    token_out_decimals: int | None = None,
+) -> dict[str, object]:
+    chain = normalize_chain(chain_name)
+    amount = parse_amount(amount_value)
+    token_in = override_decimals(resolve_token(chain, token_in_name), token_in_decimals)
+    token_out = override_decimals(resolve_token(chain, token_out_name), token_out_decimals)
+    human_amount = format(amount, "f")
+    link = build_swap_link(chain, token_in, token_out, human_amount, field)
+    return {
+        "action": "build_swap_link",
+        "chain": {"key": chain.key, "chainId": chain.chain_id},
+        "tokenIn": token_in,
+        "tokenOut": token_out,
+        "amount": human_amount,
+        "field": field,
+        "deepLink": link,
+    }
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description="生成 Uniswap swap deep link")
+    add_common_arguments(parser)
+    parser.add_argument(
+        "--field",
+        choices=["INPUT", "OUTPUT"],
+        default="INPUT",
+        help="value 对应输入还是输出字段",
+    )
+    args = parser.parse_args()
+
+    dump_json(
+        build_swap_link_response(
+            chain_name=args.chain,
+            token_in_name=args.token_in,
+            token_out_name=args.token_out,
+            amount_value=args.amount,
+            field=args.field,
+            token_in_decimals=args.token_in_decimals,
+            token_out_decimals=args.token_out_decimals,
+        )
+    )
+
+
+if __name__ == "__main__":
+    main()

uniswap_autopilot/swap/trading_api/permit.py

@@ -0,0 +1,41 @@
+#!/usr/bin/env python3
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+from pathlib import Path
+
+
+from uniswap_autopilot.common.common import dump_json, load_local_env
+from uniswap_autopilot.swap.trading_api.swap import build_permit_handoff, load_quote_payload
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description="从 quote 结果导出 permitData 签名包")
+    parser.add_argument("--quote-file", required=True, help="trading_api_quote.py 输出的 JSON 文件路径")
+    parser.add_argument("--output", required=True, help="导出的 permitData handoff JSON 路径")
+    parser.add_argument("--typed-data-output", help="额外导出标准 EIP-712 typed data JSON 路径")
+    args = parser.parse_args()
+
+    try:
+        load_local_env()
+        quote_blob = load_quote_payload(args.quote_file)
+        handoff = build_permit_handoff(raw_quote=quote_blob["rawQuote"], quote_file=args.quote_file)
+        Path(args.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)
+    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()