@agentlayer.tech/wallet 0.1.36 → 0.1.43

package/.openclaw/extensions/agent-wallet/openclaw.plugin.json

@@ -2,7 +2,7 @@
   "id": "agent-wallet",
   "name": "Agent Wallet",
   "description": "Official OpenClaw plugin bridge for the agent-wallet backends, including Solana, local BTC, and local EVM.",
-  "version": "0.1.36",
+  "version": "0.1.43",
   "contracts": {
     "tools": [
       "close_empty_token_accounts",

package/.openclaw/extensions/agent-wallet/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agentlayertech/agent-wallet-plugin",
-  "version": "0.1.36",
+  "version": "0.1.43",
   "description": "OpenClaw plugin bridge for the AgentLayer wallet runtime.",
   "type": "module",
   "license": "SEE LICENSE IN ../../../LICENSE",

package/CHANGELOG.md

@@ -2,6 +2,43 @@
 
 ## Unreleased
 
+## v0.1.41 - 2026-06-07
+
+- Hardened Uniswap Trading API swap execution on active EVM mainnet markets.
+  - Stabilized the Uniswap quote fingerprint so `preview -> execute` binds to
+    the swap intent rather than a per-block quoted output amount, preventing
+    harmless repricing from failing execute with `swap_quote_changed`.
+  - Raised the default Uniswap slippage floor from `50` bps to `300` bps
+    (`3%`) so normal drift during the approval/execution window on Base no
+    longer causes avoidable failures. Per-call and env overrides still apply.
+- Made the local `wdk-evm-wallet` daemon version-aware and self-refreshing.
+  - `/health` now reports the real launcher version instead of a hardcoded
+    `0.1.0`.
+  - Local EVM autostart compares the running daemon version against the on-disk
+    launcher version and automatically restarts a stale daemon after local
+    release/install, avoiding old code staying resident in memory.
+- Extended the long-running EVM HTTP timeout policy to the Uniswap
+  `/v1/evm/uniswap/swap/{quote,send}` routes so approve+swap flows on Base do
+  not time out client-side while the daemon is still finishing the on-chain
+  operation.
+
+## v0.1.37 - 2026-06-05
+
+- Fixed the Claude Code / Codex MCP bridge failing to start with
+  `MCP error -32000: Connection closed` when the plugin is run through a
+  marketplace symlink. run_mcp.sh resolved PLUGIN_ROOT with a logical `pwd`, so
+  the symlink stayed in the path and the sibling-codex fallback (`../../../codex`)
+  collapsed lexically into a non-existent path. The launcher now resolves paths
+  physically (`pwd -P`), keeping the `..` arithmetic consistent with the real
+  layout, with a regression test that drives the launcher through a symlink.
+
+## v0.1.36 - 2026-06-03
+
+- Installer no longer pins a redundant `OPENCLAW_HOME` into the version-controlled
+  bundle `.mcp.json` when the install home is the default `~/.openclaw`
+  (run_mcp.sh already derives it). Any stale pin is removed so the tracked file
+  self-heals to a clean state; non-default homes still pin as before.
+
 ## v0.1.35 - 2026-06-03
 
 - Hardened the Codex / Claude Code MCP wallet bridge:

package/README.md

@@ -6,10 +6,18 @@
 [![docs](https://img.shields.io/badge/docs-agent--layer.tech-blue)](https://docs.agent-layer.tech/)
 [![license](https://img.shields.io/github/license/lopushok9/Agent-Layer)](https://github.com/lopushok9/Agent-Layer/blob/main/LICENSE)
 
+For Openclaw:
+
 ```bash
 npx @agentlayer.tech/wallet install --yes
 ```
 
+For Codex:
+
+```bash
+npx @agentlayer.tech/wallet install --yes && npx @agentlayer.tech/wallet codex install --yes
+```
+
 For Hermes:
 
 ```bash

package/VERSION

@@ -1 +1 @@
-0.1.36
+0.1.43

package/agent-wallet/agent_wallet/__init__.py

@@ -2,7 +2,7 @@
 
 # Keep in sync with package.json, pyproject.toml, and the npm installer version.
 # scripts/check_release_version.mjs enforces this on release.
-__version__ = "0.1.36"
+__version__ = "0.1.43"
 
 __all__ = [
     "config",

package/agent-wallet/agent_wallet/evm_user_wallets.py

@@ -5,6 +5,8 @@ from __future__ import annotations
 import json
 import os
 import secrets
+import shutil
+import signal
 import subprocess
 import time
 from pathlib import Path
@@ -50,12 +52,103 @@ def _health_url(service_url: str) -> str:
     return f"{service_url.rstrip('/')}/health"
 
 
-def _service_is_healthy(service_url: str) -> bool:
+def _service_health(service_url: str) -> dict[str, Any] | None:
+    """Return the parsed /health payload, or None if the service is down.
+
+    An empty dict means the service answered 200 but the body was unparseable —
+    treated as "running, version unknown" so we never restart on a parse blip.
+    """
     try:
         with urlopen(_health_url(service_url), timeout=1.5) as response:
-            return int(getattr(response, "status", 0) or 0) == 200
+            if int(getattr(response, "status", 0) or 0) != 200:
+                return None
+            raw = response.read()
     except (URLError, TimeoutError, OSError):
-        return False
+        return None
+    try:
+        payload = json.loads(raw.decode("utf-8"))
+    except (ValueError, UnicodeDecodeError):
+        return {}
+    return payload if isinstance(payload, dict) else {}
+
+
+def _service_is_healthy(service_url: str) -> bool:
+    return _service_health(service_url) is not None
+
+
+def _read_on_disk_service_version(wallet_root: Path) -> str | None:
+    """Version the launcher in wallet_root would report once (re)started."""
+    try:
+        pkg = json.loads((wallet_root / "package.json").read_text(encoding="utf-8"))
+    except (OSError, ValueError):
+        return None
+    version = str(pkg.get("version") or "").strip()
+    return version or None
+
+
+def _listening_pids(port: int) -> list[int]:
+    """PIDs LISTENing on a local TCP port (via lsof), excluding our own."""
+    lsof = shutil.which("lsof")
+    if not lsof:
+        return []
+    try:
+        completed = subprocess.run(  # noqa: S603
+            [lsof, "-t", "-i", f"tcp:{port}", "-sTCP:LISTEN"],
+            capture_output=True,
+            text=True,
+            timeout=5,
+        )
+    except (OSError, subprocess.SubprocessError):
+        return []
+    pids: list[int] = []
+    for token in completed.stdout.split():
+        token = token.strip()
+        if token.isdigit():
+            pid = int(token)
+            if pid != os.getpid():
+                pids.append(pid)
+    return pids
+
+
+def _stop_local_service(service_url: str) -> None:
+    """Gracefully stop a local wdk-evm-wallet daemon so a fresh one can start.
+
+    SIGTERM the listener(s), wait for /health to drop, then SIGKILL as a fallback.
+    """
+    port = urlparse(service_url).port or 8081
+    pids = _listening_pids(port)
+    if not pids:
+        # Nothing identifiable to stop (e.g. lsof missing). Surface a clear,
+        # actionable error rather than racing into an EADDRINUSE start failure.
+        raise WalletBackendError(
+            f"A stale wdk-evm-wallet is running on port {port} but could not be "
+            "identified to restart it. Stop it manually and retry."
+        )
+    for pid in pids:
+        try:
+            os.kill(pid, signal.SIGTERM)
+        except ProcessLookupError:
+            continue
+        except PermissionError as exc:
+            raise WalletBackendError(
+                f"Cannot stop stale wdk-evm-wallet (pid {pid}): {exc}."
+            ) from exc
+    deadline = time.time() + 10.0
+    while time.time() < deadline:
+        if _service_health(service_url) is None:
+            return
+        time.sleep(0.3)
+    for pid in _listening_pids(port):
+        try:
+            os.kill(pid, signal.SIGKILL)
+        except ProcessLookupError:
+            continue
+    deadline = time.time() + 5.0
+    while time.time() < deadline:
+        if _service_health(service_url) is None:
+            return
+        time.sleep(0.3)
+    raise WalletBackendError(f"Failed to stop stale wdk-evm-wallet on port {port}.")
 
 
 def _is_local_service_url(service_url: str) -> bool:
@@ -80,13 +173,28 @@ def _resolve_local_wdk_evm_root() -> Path | None:
 
 
 def _auto_start_local_service(service_url: str, network: str) -> None:
-    if _service_is_healthy(service_url):
-        return
+    wallet_root = _resolve_local_wdk_evm_root()
+    health = _service_health(service_url)
+    if health is not None:
+        # Already running. The daemon loads code once at boot (no hot-reload), so a
+        # long-running process keeps serving stale code after a release. Restart it
+        # only when its reported version differs from the on-disk launcher version —
+        # comparing against the version the restarted daemon will itself report keeps
+        # this idempotent (steady state = no-op) and free of restart loops. Remote
+        # (non-local) healthy services we don't manage are left untouched.
+        if not _is_local_service_url(service_url):
+            return
+        expected_version = (
+            _read_on_disk_service_version(wallet_root) if wallet_root is not None else None
+        )
+        running_version = str(health.get("version") or "").strip()
+        if expected_version is None or running_version == expected_version:
+            return
+        _stop_local_service(service_url)
     if not _is_local_service_url(service_url):
         raise WalletBackendError(
             f"wdk-evm-wallet is unreachable at {_health_url(service_url)} and auto-start only supports localhost URLs."
         )
-    wallet_root = _resolve_local_wdk_evm_root()
     if wallet_root is None:
         raise WalletBackendError(
             "wdk-evm-wallet is not healthy and the local launcher could not be found."

package/agent-wallet/agent_wallet/openclaw_adapter.py

@@ -476,6 +476,26 @@ class OpenClawWalletAdapter:
                 "evm_swap_fingerprint": evm_swap_fingerprint,
             }
 
+        if asset_type == "evm-uniswap-swap":
+            provided_fingerprint = payload.get("quote_fingerprint")
+            return {
+                "operation": action_label,
+                "network": str(payload.get("network") or getattr(self.backend, "network", "unknown")),
+                "wallet": payload.get("wallet"),
+                "from_address": payload.get("from_address"),
+                "swap_provider": payload.get("swap_provider"),
+                "routing": payload.get("routing"),
+                "token_in": payload.get("token_in"),
+                "token_out": payload.get("token_out"),
+                "input_amount_raw": payload.get("input_amount_raw"),
+                "estimated_output_amount_raw": payload.get("estimated_output_amount_raw"),
+                "minimum_output_amount_raw": payload.get("minimum_output_amount_raw"),
+                "slippage_bps": payload.get("slippage_bps"),
+                "permit_required": payload.get("permit_required"),
+                "router": payload.get("router"),
+                "quote_fingerprint": provided_fingerprint,
+            }
+
         if asset_type == "evm-aave-v3":
             return {
                 "operation": action_label,
@@ -804,6 +824,13 @@ class OpenClawWalletAdapter:
         is_mainnet = self._is_mainnet_network(network)
         annotated["network"] = network
         annotated["is_mainnet"] = is_mainnet
+        # Stamp the mode so the host bridge can cache preview/prepare responses for
+        # auto-approval at execute. The bridge already treats "preview" as cacheable
+        # (alongside "prepare"/"intent_preview"); without this field a preview -> execute
+        # flow never caches and execute fails with "confirmation context expired",
+        # regardless of timing. prepare carries its own mode via _build_prepare_plan;
+        # "execute" responses stay uncached (not in the bridge's cacheable set).
+        annotated["mode"] = mode
         annotated["confirmation_summary"] = self._build_confirmation_summary(
             action_label=action_label,
             payload=annotated,
@@ -1587,6 +1614,131 @@ class OpenClawWalletAdapter:
                         risk_level="high",
                     ),
                 )
+                tools.insert(
+                    11,
+                    AgentToolSpec(
+                        name="get_uniswap_swap_quote",
+                        description=(
+                            "Get a read-only Uniswap Trading API quote (CLASSIC routing) for an ERC-20 or native ETH swap "
+                            "on ethereum or base. Supports full EIP-712 Permit2 path for ERC-20 inputs. "
+                            "This does not approve, sign, or execute a swap."
+                        ),
+                        input_schema={
+                            "type": "object",
+                            "properties": {
+                                "token_in": {
+                                    "type": "string",
+                                    "description": "ERC-20 contract address for the input token, or native/eth for native ETH.",
+                                },
+                                "token_out": {
+                                    "type": "string",
+                                    "description": "ERC-20 contract address for the output token, or native/eth for native ETH.",
+                                },
+                                "amount_in_raw": {
+                                    "type": "string",
+                                    "description": "Input amount in token base units as a base-10 integer string.",
+                                },
+                                "slippage_bps": {
+                                    "type": "integer",
+                                    "description": "Optional slippage tolerance in basis points (e.g. 50 = 0.5%, 300 = 3%). Defaults to 300.",
+                                },
+                                "network": {
+                                    "type": "string",
+                                    "enum": ["ethereum", "base"],
+                                    "description": "EVM network. Uniswap Trading API supports ethereum and base only.",
+                                },
+                            },
+                            "required": ["token_in", "token_out", "amount_in_raw"],
+                            "additionalProperties": False,
+                        },
+                        read_only=True,
+                        risk_level="low",
+                    ),
+                )
+                tools.insert(
+                    12,
+                    AgentToolSpec(
+                        name="swap_evm_uniswap_tokens",
+                        description=(
+                            "Preview, prepare, or execute an ERC-20 or native ETH swap through the Uniswap Trading API "
+                            "(CLASSIC routing) on ethereum or base. ERC-20 inputs use Permit2 EIP-712 signing automatically. "
+                            "Prepare returns an execution plan only. Execute requires a host-issued approval token bound to the previewed operation."
+                        ),
+                        input_schema={
+                            "type": "object",
+                            "properties": {
+                                "token_in": {
+                                    "type": "string",
+                                    "description": "ERC-20 contract address or native/eth for native ETH.",
+                                },
+                                "token_out": {
+                                    "type": "string",
+                                    "description": "ERC-20 contract address or native/eth for native ETH.",
+                                },
+                                "amount_in_raw": {
+                                    "type": "string",
+                                    "description": "Input amount in token base units as a base-10 integer string.",
+                                },
+                                "slippage_bps": {
+                                    "type": "integer",
+                                    "description": "Optional slippage tolerance in basis points (e.g. 50 = 0.5%, 300 = 3%). Defaults to 300.",
+                                },
+                                "mode": {
+                                    "type": "string",
+                                    "enum": ["preview", "prepare", "execute"],
+                                },
+                                "purpose": {"type": "string"},
+                                "user_intent": {"type": "boolean"},
+                                "approval_token": {"type": "string"},
+                                "network": {
+                                    "type": "string",
+                                    "enum": ["ethereum", "base"],
+                                    "description": "EVM network. Uniswap Trading API supports ethereum and base only.",
+                                },
+                            },
+                            "required": ["token_in", "token_out", "amount_in_raw", "mode", "purpose"],
+                            "additionalProperties": False,
+                        },
+                        read_only=False,
+                        requires_explicit_user_intent=True,
+                        risk_level="high",
+                    ),
+                )
+                tools.insert(
+                    13,
+                    AgentToolSpec(
+                        name="issue_wallet_approval",
+                        description=(
+                            "Issue a host approval token bound to an exact wallet operation. "
+                            "Call this after prepare mode to get the token required for execute mode. "
+                            "Pass tool_name and the confirmation_summary exactly as returned in the prepare response. "
+                            "In Claude Code this is the bridge step that Codex performs automatically via its UI dialog."
+                        ),
+                        input_schema={
+                            "type": "object",
+                            "properties": {
+                                "tool_name": {
+                                    "type": "string",
+                                    "description": "Name of the tool being approved, e.g. swap_evm_uniswap_tokens or swap_evm_tokens.",
+                                },
+                                "summary": {
+                                    "type": "object",
+                                    "description": "The confirmation_summary dict returned verbatim from the prepare response.",
+                                    "additionalProperties": True,
+                                },
+                                "mainnet_confirmed": {
+                                    "type": "boolean",
+                                    "description": "Set to true to confirm this is a mainnet operation and you accept the risk.",
+                                },
+                            },
+                            "required": ["tool_name", "summary", "mainnet_confirmed"],
+                            "additionalProperties": False,
+                        },
+                        read_only=False,
+                        requires_explicit_user_intent=True,
+                        risk_level="high",
+                    ),
+                )
 
             return tools
 
@@ -3753,6 +3905,185 @@ class OpenClawWalletAdapter:
                     ),
                 )
 
+            if tool_name == "get_uniswap_swap_quote":
+                token_in = args.get("token_in")
+                token_out = args.get("token_out")
+                amount_in_raw = args.get("amount_in_raw")
+                slippage_bps = args.get("slippage_bps")
+                if not isinstance(token_in, str) or not token_in.strip():
+                    raise WalletBackendError("token_in is required.")
+                if not isinstance(token_out, str) or not token_out.strip():
+                    raise WalletBackendError("token_out is required.")
+                if not isinstance(amount_in_raw, str) or not amount_in_raw.strip().isdigit():
+                    raise WalletBackendError("amount_in_raw must be a positive integer string.")
+                if int(amount_in_raw.strip()) <= 0:
+                    raise WalletBackendError("amount_in_raw must be greater than zero.")
+                if slippage_bps is not None and (not isinstance(slippage_bps, int) or slippage_bps < 0 or slippage_bps > 5000):
+                    raise WalletBackendError("slippage_bps must be an integer between 0 and 5000.")
+                data = await active_backend.get_uniswap_swap_quote(
+                    token_in=token_in.strip(),
+                    token_out=token_out.strip(),
+                    amount_in_raw=amount_in_raw.strip(),
+                    slippage_bps=slippage_bps,
+                )
+                return AgentToolResult(tool=tool_name, ok=True, data=data)
+
+            if tool_name == "swap_evm_uniswap_tokens":
+                token_in = args.get("token_in")
+                token_out = args.get("token_out")
+                amount_in_raw = args.get("amount_in_raw")
+                slippage_bps = args.get("slippage_bps")
+                mode = args.get("mode")
+                purpose = args.get("purpose")
+                user_intent = args.get("user_intent", False)
+                approval_token = args.get("approval_token")
+
+                if not isinstance(token_in, str) or not token_in.strip():
+                    raise WalletBackendError("token_in is required.")
+                if not isinstance(token_out, str) or not token_out.strip():
+                    raise WalletBackendError("token_out is required.")
+                if not isinstance(amount_in_raw, str) or not amount_in_raw.strip().isdigit():
+                    raise WalletBackendError("amount_in_raw must be a positive integer string.")
+                if int(amount_in_raw.strip()) <= 0:
+                    raise WalletBackendError("amount_in_raw must be greater than zero.")
+                if mode not in {"preview", "prepare", "execute"}:
+                    raise WalletBackendError("mode must be 'preview', 'prepare' or 'execute'.")
+                if not isinstance(purpose, str) or not purpose.strip():
+                    raise WalletBackendError("purpose is required.")
+                if slippage_bps is not None and (not isinstance(slippage_bps, int) or slippage_bps < 0 or slippage_bps > 5000):
+                    raise WalletBackendError("slippage_bps must be an integer between 0 and 5000.")
+
+                preview_kwargs = {
+                    "token_in": token_in.strip(),
+                    "token_out": token_out.strip(),
+                    "amount_in_raw": amount_in_raw.strip(),
+                    "slippage_bps": slippage_bps,
+                }
+
+                if mode == "preview":
+                    preview = await active_backend.preview_uniswap_swap(**preview_kwargs)
+                    return AgentToolResult(
+                        tool=tool_name,
+                        ok=True,
+                        data=self._annotate_sensitive_payload(
+                            preview,
+                            action_label="Uniswap swap",
+                            mode="preview",
+                        ),
+                    )
+
+                if mode == "prepare":
+                    self._require_prepare_intent(user_intent)
+                    preview = await active_backend.preview_uniswap_swap(**preview_kwargs)
+                    return AgentToolResult(
+                        tool=tool_name,
+                        ok=True,
+                        data=self._annotate_sensitive_payload(
+                            self._build_prepare_plan(
+                                preview_payload=preview,
+                                action_label="Uniswap swap",
+                            ),
+                            action_label="Uniswap swap",
+                            mode="prepare",
+                        ),
+                    )
+
+                approval_payload = inspect_approval_token(
+                    approval_token,
+                    tool_name=tool_name,
+                    network=str(getattr(active_backend, "network", "unknown")),
+                    require_mainnet_confirmation=self._is_mainnet_for_backend(active_backend),
+                )
+                approval_summary = approval_payload.get("binding", {}).get("summary")
+                if not isinstance(approval_summary, dict):
+                    raise WalletBackendError(
+                        "approval_token does not match the requested operation. Generate a new approval after previewing the exact action."
+                    )
+                expected_summary = {
+                    "operation": "Uniswap swap",
+                    "network": str(getattr(active_backend, "network", "unknown")),
+                    "token_in": token_in.strip(),
+                    "token_out": token_out.strip(),
+                    "input_amount_raw": amount_in_raw.strip(),
+                }
+                for key, expected_value in expected_summary.items():
+                    if approval_summary.get(key) != expected_value:
+                        raise WalletBackendError(
+                            "approval_token does not match the requested operation. Generate a new approval after previewing the exact action."
+                        )
+
+                approval_summary_copy = dict(approval_summary)
+                self._require_execute_approval(
+                    approval_token=approval_token,
+                    tool_name=tool_name,
+                    summary=approval_summary_copy,
+                    action_label="Uniswap swap",
+                    backend=active_backend,
+                )
+                bound_quote_fingerprint = approval_summary_copy.get("quote_fingerprint")
+                bound_minimum_output_amount_raw = approval_summary_copy.get("minimum_output_amount_raw")
+                result = await active_backend.send_uniswap_swap(
+                    **preview_kwargs,
+                    expected_quote_fingerprint=(
+                        bound_quote_fingerprint.strip()
+                        if isinstance(bound_quote_fingerprint, str) and bound_quote_fingerprint.strip()
+                        else None
+                    ),
+                    minimum_output_amount_raw=(
+                        str(bound_minimum_output_amount_raw).strip()
+                        if bound_minimum_output_amount_raw is not None
+                        else None
+                    ),
+                )
+                return AgentToolResult(
+                    tool=tool_name,
+                    ok=True,
+                    data=self._annotate_sensitive_payload(
+                        result,
+                        action_label="Uniswap swap",
+                        mode="execute",
+                    ),
+                )
+
+            if tool_name == "issue_wallet_approval":
+                from agent_wallet.approval import issue_approval_token
+
+                target_tool = args.get("tool_name")
+                summary = args.get("summary")
+                mainnet_confirmed = args.get("mainnet_confirmed", False)
+
+                if not isinstance(target_tool, str) or not target_tool.strip():
+                    raise WalletBackendError("tool_name is required.")
+                if not isinstance(summary, dict) or not summary:
+                    raise WalletBackendError("summary must be a non-empty object matching the prepare response confirmation_summary.")
+                if not isinstance(mainnet_confirmed, bool):
+                    raise WalletBackendError("mainnet_confirmed must be a boolean.")
+                if self._is_mainnet_for_backend(active_backend) and not mainnet_confirmed:
+                    raise WalletBackendError(
+                        "mainnet_confirmed must be true for mainnet operations. "
+                        "Set mainnet_confirmed: true to confirm you accept the risk of an irreversible mainnet transaction."
+                    )
+
+                network = str(getattr(active_backend, "network", "unknown"))
+                token = issue_approval_token(
+                    tool_name=target_tool.strip(),
+                    network=network,
+                    summary=summary,
+                    mainnet_confirmed=mainnet_confirmed,
+                    issued_by="claude-code-bridge",
+                )
+                return AgentToolResult(
+                    tool=tool_name,
+                    ok=True,
+                    data={
+                        "approval_token": token,
+                        "tool_name": target_tool.strip(),
+                        "network": network,
+                        "mainnet_confirmed": mainnet_confirmed,
+                        "usage": f"Pass approval_token to {target_tool.strip()} with mode='execute'.",
+                    },
+                )
+
             if tool_name == "get_wallet_portfolio":
                 address = args.get("address")
                 if address is not None and not isinstance(address, str):

package/agent-wallet/agent_wallet/providers/wdk_evm_local.py

@@ -26,6 +26,8 @@ LONG_RUNNING_POST_PATHS = {
     "/v1/evm/lido/claim_withdrawal/send",
     "/v1/evm/swap/quote",
     "/v1/evm/swap/send",
+    "/v1/evm/uniswap/swap/quote",
+    "/v1/evm/uniswap/swap/send",
     "/v1/evm/lifi/quote",
     "/v1/evm/lifi/send",
     "/v1/evm/transfer/send",

package/agent-wallet/agent_wallet/wallet_layer/base.py

@@ -226,6 +226,38 @@ class AgentWalletBackend(ABC):
     ) -> dict[str, Any]:
         raise WalletBackendError(f"{self.name} does not support EVM LI.FI cross-chain swaps.")
 
+    async def get_uniswap_swap_quote(
+        self,
+        *,
+        token_in: str,
+        token_out: str,
+        amount_in_raw: str,
+        slippage_bps: int | None = None,
+    ) -> dict[str, Any]:
+        raise WalletBackendError(f"{self.name} does not support Uniswap swap quotes.")
+
+    async def preview_uniswap_swap(
+        self,
+        *,
+        token_in: str,
+        token_out: str,
+        amount_in_raw: str,
+        slippage_bps: int | None = None,
+    ) -> dict[str, Any]:
+        raise WalletBackendError(f"{self.name} does not support Uniswap swap previews.")
+
+    async def send_uniswap_swap(
+        self,
+        *,
+        token_in: str,
+        token_out: str,
+        amount_in_raw: str,
+        slippage_bps: int | None = None,
+        expected_quote_fingerprint: str | None = None,
+        minimum_output_amount_raw: str | None = None,
+    ) -> dict[str, Any]:
+        raise WalletBackendError(f"{self.name} does not support Uniswap swaps.")
+
     async def preview_evm_native_transfer(
         self,
         *,