@agentlayer.tech/wallet 0.1.84 → 0.1.89

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.84",
+  "version": "0.1.89",
   "contracts": {
     "tools": [
       "agentlayer_autonomous_approve",
@@ -61,6 +61,7 @@
       "manage_evm_morpho_vault_position",
       "manage_evm_lido_position",
       "manage_evm_lido_withdrawal",
+      "search_uniswap_pairs",
       "set_evm_network",
       "set_wallet_backend",
       "sign_wallet_message",

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

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

package/CHANGELOG.md

@@ -2,6 +2,21 @@
 
 ## Unreleased
 
+- Hardened Morpho EVM operations with a 30% gas-limit buffer calculated from
+  the exact final calldata immediately before sending. Morpho vault and market
+  writes now wait for their final on-chain receipt and report reverts instead
+  of returning an unconfirmed broadcast as a successful operation.
+
+- Extended the same exact-calldata 30% gas-limit buffer and receipt validation
+  to Aave, Lido, Velora, LI.FI, and locally broadcast Uniswap swaps. This
+  includes Robinhood Chain's Universal Router, direct V3 fallback, and native
+  wrap/unwrap paths; UniswapX orders remain order submissions, not local
+  on-chain confirmations.
+
+- Fixed the Robinhood Chain Uniswap default to Universal Router `2.1.1`.
+  `UNISWAP_ROUTER_VERSION_BY_NETWORK` can still explicitly override it per
+  network; the legacy global `2.0` default continues to serve Ethereum and Base.
+
 ## v0.1.77 - 2026-07-13
 
 - Added Robinhood Chain mainnet (`chainId` 4663) to the local EVM wallet,

package/VERSION

@@ -1 +1 @@
-0.1.84
+0.1.89

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.84"
+__version__ = "0.1.89"
 
 __all__ = [
     "config",

package/agent-wallet/agent_wallet/openclaw_adapter.py

@@ -2211,6 +2211,67 @@ class OpenClawWalletAdapter:
                         risk_level="low",
                     ),
                 )
+                tools.append(
+                    AgentToolSpec(
+                        name="search_uniswap_pairs",
+                        description=(
+                            "Search for onchain Uniswap-tradeable token pairs by ticker/name or by exact "
+                            "ERC-20 address, with live price, 5m/1h/6h/24h volume, liquidity, FDV, market "
+                            "cap, and buy/sell counts. Backed by DexScreener's public index (covers "
+                            "Uniswap v2/v3/v4 pools and other DEXes on the same chain), since the Uniswap "
+                            "Trading API itself only quotes a pair you already know the addresses for, not "
+                            "search-by-name. Defaults to the currently active EVM network (e.g. robinhood); "
+                            "set all_chains to search across every chain DexScreener indexes. Read-only "
+                            "market data, not a swap quote. Free-text search can surface impersonator "
+                            "tokens reusing a legitimate ticker with fabricated liquidity/FDV — before "
+                            "quoting or swapping, verify the token_address independently (e.g. via "
+                            "get_evm_token_metadata) rather than trusting the top result by symbol match. "
+                            "Do not use liquidity/FDV size to pick a winner: observed impersonators on "
+                            "robinhood fabricate liquidity/FDV an order of magnitude above the genuine "
+                            "pool specifically to look most trustworthy, and a Uniswap quote succeeding "
+                            "for a token proves nothing either (Trading API routes any pool with reserves, "
+                            "impersonators included). This only matters for tickers claiming to represent "
+                            "a real-world asset (stocks/ETFs) - unrelated meme/community tokens on the "
+                            "same chain aren't impersonators just for lacking a canonical issuer. When the "
+                            "query is a real-world-asset ticker, cross-check the returned token_address "
+                            "against Robinhood's own canonical list at docs.robinhood.com/chain/contracts "
+                            "(or the equivalent official source for other chains) before relying on the result."
+                        ),
+                        input_schema={
+                            "type": "object",
+                            "properties": {
+                                "query": {
+                                    "type": "string",
+                                    "description": "Free-text search, e.g. a ticker or name (\"AAPL\", \"Apple Robinhood\"). Required unless token_address is given.",
+                                },
+                                "token_address": {
+                                    "type": "string",
+                                    "description": "Exact ERC-20 contract address to look up instead of a free-text query.",
+                                },
+                                "chain": {
+                                    "type": "string",
+                                    "description": "DexScreener chain slug to filter to (e.g. \"robinhood\", \"ethereum\", \"base\"). Defaults to the active EVM network.",
+                                },
+                                "dex_id": {
+                                    "type": "string",
+                                    "description": "Optional exact DEX filter, e.g. \"uniswap\".",
+                                },
+                                "all_chains": {
+                                    "type": "boolean",
+                                    "description": "If true, do not filter query results to a single chain. Ignored when token_address is set.",
+                                },
+                                "limit": {
+                                    "type": "integer",
+                                    "description": "Max number of pairs to return (1-30). Defaults to 10.",
+                                },
+                            },
+                            "required": [],
+                            "additionalProperties": False,
+                        },
+                        read_only=True,
+                        risk_level="low",
+                    ),
+                )
                 tools.insert(
                     12,
                     AgentToolSpec(
@@ -5460,6 +5521,37 @@ class OpenClawWalletAdapter:
                 )
                 return AgentToolResult(tool=tool_name, ok=True, data=data)
 
+            if tool_name == "search_uniswap_pairs":
+                query = args.get("query")
+                token_address = args.get("token_address")
+                chain = args.get("chain")
+                dex_id = args.get("dex_id")
+                all_chains = bool(args.get("all_chains", False))
+                limit = args.get("limit", 10)
+                if query is not None and not isinstance(query, str):
+                    raise WalletBackendError("query must be a string.")
+                if token_address is not None and not isinstance(token_address, str):
+                    raise WalletBackendError("token_address must be a string.")
+                if not (isinstance(query, str) and query.strip()) and not (
+                    isinstance(token_address, str) and token_address.strip()
+                ):
+                    raise WalletBackendError("Either query or token_address is required.")
+                if chain is not None and not isinstance(chain, str):
+                    raise WalletBackendError("chain must be a string.")
+                if dex_id is not None and not isinstance(dex_id, str):
+                    raise WalletBackendError("dex_id must be a string.")
+                if not isinstance(limit, int) or limit < 1 or limit > 30:
+                    raise WalletBackendError("limit must be an integer between 1 and 30.")
+                data = await active_backend.search_uniswap_pairs(
+                    query=query,
+                    token_address=token_address,
+                    chain=chain,
+                    dex_id=dex_id,
+                    all_chains=all_chains,
+                    limit=limit,
+                )
+                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")

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

@@ -0,0 +1,145 @@
+"""DexScreener provider for onchain token/pair discovery (price, volume, liquidity).
+
+Public API, no key required: https://docs.dexscreener.com/api/reference. Used to
+answer "which pairs exist for this token/ticker" the way app.uniswap.org's own
+search box does, since the Uniswap Trading API itself only exposes quote/order/swap
+for a pair you already know, not a search-by-name/address endpoint.
+"""
+
+from __future__ import annotations
+
+import time
+from typing import Any
+
+from agent_wallet.exceptions import ProviderError
+from agent_wallet.http_client import get_client
+
+DEXSCREENER_BASE_URL = "https://api.dexscreener.com"
+
+# DexScreener's own responses are served with `cache-control: public, max-age=30`;
+# mirroring that TTL avoids redundant lookups within a session without serving
+# data staler than DexScreener itself would.
+_CACHE_TTL_SECONDS = 30
+_CACHE_MAX_ENTRIES = 128
+_cache: dict[str, tuple[float, list[dict[str, Any]]]] = {}
+
+
+def _cache_get(key: str) -> list[dict[str, Any]] | None:
+    entry = _cache.get(key)
+    if entry is None:
+        return None
+    stored_at, pairs = entry
+    if time.monotonic() - stored_at > _CACHE_TTL_SECONDS:
+        _cache.pop(key, None)
+        return None
+    return pairs
+
+
+def _cache_set(key: str, pairs: list[dict[str, Any]]) -> None:
+    if len(_cache) >= _CACHE_MAX_ENTRIES and key not in _cache:
+        oldest_key = min(_cache, key=lambda existing: _cache[existing][0])
+        _cache.pop(oldest_key, None)
+    _cache[key] = (time.monotonic(), pairs)
+
+
+async def _get(path: str, *, params: dict[str, Any] | None = None) -> Any:
+    client = get_client()
+    response = await client.get(f"{DEXSCREENER_BASE_URL}{path}", params=params)
+    if response.status_code != 200:
+        raise ProviderError("dexscreener", f"HTTP {response.status_code}: {response.text[:300]}")
+    try:
+        return response.json()
+    except ValueError as exc:
+        raise ProviderError("dexscreener", "Unexpected non-JSON response from DexScreener.") from exc
+
+
+def _extract_pairs(data: Any) -> list[dict[str, Any]]:
+    if isinstance(data, dict):
+        pairs = data.get("pairs")
+        return pairs if isinstance(pairs, list) else []
+    if isinstance(data, list):
+        return [item for item in data if isinstance(item, dict)]
+    return []
+
+
+async def search_pairs(query: str) -> list[dict[str, Any]]:
+    """Free-text search across every chain/DEX DexScreener indexes."""
+    query = query.strip()
+    if not query:
+        raise ProviderError("dexscreener", "query must not be empty.")
+    cache_key = f"search:{query.lower()}"
+    cached = _cache_get(cache_key)
+    if cached is not None:
+        return cached
+    data = await _get("/latest/dex/search", params={"q": query})
+    pairs = _extract_pairs(data)
+    _cache_set(cache_key, pairs)
+    return pairs
+
+
+async def get_pairs_for_token(*, chain: str, token_address: str) -> list[dict[str, Any]]:
+    """All pairs for a single token address on one chain, across every DEX on it."""
+    chain = chain.strip().lower()
+    token_address = token_address.strip()
+    if not chain:
+        raise ProviderError("dexscreener", "chain must not be empty.")
+    if not token_address:
+        raise ProviderError("dexscreener", "token_address must not be empty.")
+    cache_key = f"token:{chain}:{token_address.lower()}"
+    cached = _cache_get(cache_key)
+    if cached is not None:
+        return cached
+    data = await _get(f"/tokens/v1/{chain}/{token_address}")
+    pairs = _extract_pairs(data)
+    _cache_set(cache_key, pairs)
+    return pairs
+
+
+def normalize_pair(pair: dict[str, Any]) -> dict[str, Any]:
+    """Flatten a DexScreener pair payload into the shape handed back to the agent."""
+    base_token = pair.get("baseToken") or {}
+    quote_token = pair.get("quoteToken") or {}
+    volume = pair.get("volume") or {}
+    liquidity = pair.get("liquidity") or {}
+    price_change = pair.get("priceChange") or {}
+    txns = pair.get("txns") or {}
+    return {
+        "chain_id": pair.get("chainId"),
+        "dex_id": pair.get("dexId"),
+        "pair_address": pair.get("pairAddress"),
+        "url": pair.get("url"),
+        "labels": pair.get("labels") or [],
+        "base_token": {
+            "address": base_token.get("address"),
+            "name": base_token.get("name"),
+            "symbol": base_token.get("symbol"),
+        },
+        "quote_token": {
+            "address": quote_token.get("address"),
+            "name": quote_token.get("name"),
+            "symbol": quote_token.get("symbol"),
+        },
+        "price_usd": pair.get("priceUsd"),
+        "price_native": pair.get("priceNative"),
+        "price_change_pct": {
+            "m5": price_change.get("m5"),
+            "h1": price_change.get("h1"),
+            "h6": price_change.get("h6"),
+            "h24": price_change.get("h24"),
+        },
+        "volume_usd": {
+            "m5": volume.get("m5"),
+            "h1": volume.get("h1"),
+            "h6": volume.get("h6"),
+            "h24": volume.get("h24"),
+        },
+        "txns": {
+            window: {"buys": counts.get("buys"), "sells": counts.get("sells")}
+            for window, counts in txns.items()
+            if isinstance(counts, dict)
+        },
+        "liquidity_usd": liquidity.get("usd"),
+        "fdv_usd": pair.get("fdv"),
+        "market_cap_usd": pair.get("marketCap"),
+        "pair_created_at": pair.get("pairCreatedAt"),
+    }

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

@@ -325,6 +325,18 @@ class AgentWalletBackend(ABC):
     ) -> dict[str, Any]:
         raise WalletBackendError(f"{self.name} does not support Uniswap swap previews.")
 
+    async def search_uniswap_pairs(
+        self,
+        *,
+        query: str | None = None,
+        token_address: str | None = None,
+        chain: str | None = None,
+        dex_id: str | None = None,
+        all_chains: bool = False,
+        limit: int = 10,
+    ) -> dict[str, Any]:
+        raise WalletBackendError(f"{self.name} does not support Uniswap pair search.")
+
     async def send_uniswap_swap(
         self,
         *,

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

@@ -7,7 +7,7 @@ from typing import Any
 
 from agent_wallet.config import normalize_evm_network
 from agent_wallet.providers.evm_portfolio import build_portfolio_snapshot
-from agent_wallet.providers import lifi
+from agent_wallet.providers import dexscreener, lifi
 from agent_wallet.providers.wdk_evm_local import WdkEvmLocalClient
 from agent_wallet.wallet_layer.base import AgentWalletBackend, WalletBackendError, WalletCapabilities
 
@@ -1240,7 +1240,7 @@ class WdkEvmLocalWalletBackend(AgentWalletBackend):
                 sign_only=self.sign_only,
             ),
             "broadcasted": True,
-            "confirmed": False,
+            "confirmed": bool(data.get("confirmed")),
         }
 
     async def preview_evm_lido_operation(
@@ -1308,7 +1308,7 @@ class WdkEvmLocalWalletBackend(AgentWalletBackend):
                 sign_only=self.sign_only,
             ),
             "broadcasted": True,
-            "confirmed": False,
+            "confirmed": bool(data.get("confirmed")),
         }
 
     async def preview_evm_lido_withdrawal(
@@ -1385,7 +1385,7 @@ class WdkEvmLocalWalletBackend(AgentWalletBackend):
                 sign_only=self.sign_only,
             ),
             "broadcasted": True,
-            "confirmed": False,
+            "confirmed": bool(data.get("confirmed")),
         }
 
     async def preview_evm_morpho_vault_operation(
@@ -1480,7 +1480,7 @@ class WdkEvmLocalWalletBackend(AgentWalletBackend):
                 sign_only=self.sign_only,
             ),
             "broadcasted": True,
-            "confirmed": False,
+            "confirmed": bool(data.get("confirmed")),
         }
 
     async def preview_evm_morpho_market_operation(
@@ -1575,7 +1575,7 @@ class WdkEvmLocalWalletBackend(AgentWalletBackend):
                 sign_only=self.sign_only,
             ),
             "broadcasted": True,
-            "confirmed": False,
+            "confirmed": bool(data.get("confirmed")),
         }
 
     async def get_evm_swap_quote(
@@ -1816,7 +1816,7 @@ class WdkEvmLocalWalletBackend(AgentWalletBackend):
             "result": result,
             "chain_id": int(data.get("chainId") or 0),
             "broadcasted": True,
-            "confirmed": False,
+            "confirmed": bool(data.get("confirmed")),
             "source": "wdk-evm-wallet",
         }
 
@@ -1920,6 +1920,43 @@ class WdkEvmLocalWalletBackend(AgentWalletBackend):
             "swap_transaction": swap_transaction,
         }
 
+    async def search_uniswap_pairs(
+        self,
+        *,
+        query: str | None = None,
+        token_address: str | None = None,
+        chain: str | None = None,
+        dex_id: str | None = None,
+        all_chains: bool = False,
+        limit: int = 10,
+    ) -> dict[str, Any]:
+        query = query.strip() if isinstance(query, str) else None
+        token_address = token_address.strip() if isinstance(token_address, str) else None
+        if not query and not token_address:
+            raise WalletBackendError("Either query or token_address is required.")
+        resolved_chain = (chain or self.network).strip().lower()
+        if token_address:
+            pairs = await dexscreener.get_pairs_for_token(chain=resolved_chain, token_address=token_address)
+        else:
+            pairs = await dexscreener.search_pairs(query)
+            if not all_chains:
+                pairs = [p for p in pairs if str(p.get("chainId") or "").lower() == resolved_chain]
+        if dex_id:
+            wanted_dex = dex_id.strip().lower()
+            pairs = [p for p in pairs if str(p.get("dexId") or "").lower() == wanted_dex]
+        bounded_limit = max(1, min(int(limit or 10), 30))
+        normalized = [dexscreener.normalize_pair(pair) for pair in pairs[:bounded_limit]]
+        return {
+            "chain": None if all_chains else resolved_chain,
+            "all_chains": all_chains,
+            "query": query,
+            "token_address": token_address,
+            "dex_id": dex_id,
+            "count": len(normalized),
+            "pairs": normalized,
+            "source": "dexscreener",
+        }
+
     async def send_uniswap_swap(
         self,
         *,
@@ -1987,7 +2024,7 @@ class WdkEvmLocalWalletBackend(AgentWalletBackend):
             "chain_id": int(data.get("chainId") or 0),
             "broadcasted": bool(result.get("hash")),
             "order_submitted": order_id is not None,
-            "confirmed": False,
+            "confirmed": bool(data.get("confirmed")),
             "source": str(data.get("source") or "wdk-evm-wallet"),
         }
 
@@ -2102,7 +2139,7 @@ class WdkEvmLocalWalletBackend(AgentWalletBackend):
             "reset_allowance_hash": result.get("resetAllowanceHash"),
             "result": result,
             "broadcasted": True,
-            "confirmed": False,
+            "confirmed": bool(data.get("confirmed")),
         }
 
     async def preview_evm_native_transfer(

package/agent-wallet/openclaw.plugin.json

@@ -2,7 +2,7 @@
   "id": "agent-wallet",
   "name": "Agent Wallet",
   "description": "Plugin-friendly wallet backend for OpenClaw agents with safe wallet tools and runtime instructions across Solana, local BTC, and local EVM.",
-  "version": "0.1.84",
+  "version": "0.1.89",
   "skills": ["skills/wallet-operator"],
   "configSchema": {
     "type": "object",

package/agent-wallet/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "openclaw-agent-wallet"
-version = "0.1.84"
+version = "0.1.89"
 description = "Plugin-friendly wallet backend for OpenClaw agents"
 requires-python = ">=3.10"
 dependencies = [

package/claude-code/plugins/agent-wallet/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "agent-wallet",
   "displayName": "Agent Wallet",
-  "version": "0.1.84",
+  "version": "0.1.89",
   "description": "Claude Code bridge for the existing AgentLayer wallet runtime. Connects to Solana, Bitcoin, and EVM wallets without creating a new one.",
   "author": {
     "name": "AgentLayer"

package/codex/plugins/agent-wallet/.codex-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-wallet",
-  "version": "0.1.84",
+  "version": "0.1.89",
   "description": "Codex plugin bridge for the AgentLayer wallet runtime.",
   "author": {
     "name": "AgentLayer"

package/hermes/plugins/agent_wallet/plugin.yaml

@@ -1,5 +1,5 @@
 name: agent-wallet
-version: 0.1.84
+version: 0.1.89
 description: Thin Hermes Agent bridge to the existing AgentLayer/OpenClaw wallet backend
 provides_tools:
   - agent_wallet_tools

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agentlayer.tech/wallet",
-  "version": "0.1.84",
+  "version": "0.1.89",
   "description": "NPM installer for the OpenClaw Agent Wallet local runtime.",
   "type": "module",
   "repository": {

package/wdk-btc-wallet/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wdk-btc-wallet",
-  "version": "0.1.84",
+  "version": "0.1.89",
   "private": true,
   "type": "module",
   "description": "Separate BTC-only wallet service built on Tether WDK.",

package/wdk-evm-wallet/.env.example

@@ -29,5 +29,7 @@ UNISWAP_API_KEY=
 UNISWAP_ROUTER_VERSION=2.0
 # Optional per-network override; each value must exist in the wallet's reviewed
 # execution profile and match the provider-gateway's per-chain configuration.
-UNISWAP_ROUTER_VERSION_BY_NETWORK={"ethereum":"2.0","base":"2.0","robinhood":"2.0"}
+# Robinhood Chain has no Universal Router 2.0 deployment (Uniswap defaults it
+# to 2.1.1); requesting 2.0 makes the Trading API 404 every pair on that chain.
+UNISWAP_ROUTER_VERSION_BY_NETWORK={"ethereum":"2.0","base":"2.0","robinhood":"2.1.1"}
 UNISWAP_DEFAULT_SLIPPAGE_BPS=300

package/wdk-evm-wallet/README.md

@@ -188,6 +188,7 @@ Environment variables:
 - `UNISWAP_API_KEY`
 - `UNISWAP_TRADING_API_BASE_URL`
 - `UNISWAP_ROUTER_VERSION`
+- `UNISWAP_ROUTER_VERSION_BY_NETWORK`
 - `UNISWAP_DEFAULT_SLIPPAGE_BPS`
 
 Morpho read-only support:

package/wdk-evm-wallet/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wdk-evm-wallet",
-  "version": "0.1.84",
+  "version": "0.1.89",
   "private": true,
   "type": "module",
   "description": "Separate EVM wallet service built on Tether WDK.",

package/wdk-evm-wallet/src/config.js

@@ -57,6 +57,12 @@ const DEFAULT_NETWORK_PROFILES = {
   },
 };
 
+// Robinhood Chain uses the Universal Router 2.1.1 deployment. Keep this
+// network-specific default separate from the legacy global 2.0 setting so
+// Ethereum and Base retain their existing routers while Robinhood can quote
+// and execute without a local environment override.
+const DEFAULT_UNISWAP_ROUTER_VERSIONS_BY_NETWORK = { robinhood: "2.1.1" };
+
 const SUPPORTED_GATEWAY_PROVIDERS = new Set(["auto", "shared", "alchemy"]);
 
 function parseProviderMode(value, fallback = "public") {
@@ -192,7 +198,7 @@ function normalizeNetworkKey(value) {
 function parseUniswapRouterVersionsByNetwork(value) {
   const raw = String(value ?? "").trim();
   if (!raw) {
-    return {};
+    return { ...DEFAULT_UNISWAP_ROUTER_VERSIONS_BY_NETWORK };
   }
   let parsed;
   try {
@@ -215,7 +221,7 @@ function parseUniswapRouterVersionsByNetwork(value) {
     }
     normalized[networkKey] = normalizedVersion;
   }
-  return normalized;
+  return { ...DEFAULT_UNISWAP_ROUTER_VERSIONS_BY_NETWORK, ...normalized };
 }
 
 function joinUrl(base, pathname) {

package/wdk-evm-wallet/src/server.js

@@ -37,12 +37,21 @@ function normalizeErrorCode(errorCode, pathname, message) {
     code === "aave_quote_changed" ||
     code === "aave_approval_required" ||
     code === "aave_fee_unavailable" ||
+    code === "aave_operation_reverted" ||
+    code === "aave_operation_confirmation_timeout" ||
     code === "aave_cleanup_failed" ||
     code === "morpho_api_failed" ||
     code === "morpho_quote_changed" ||
     code === "morpho_requirements_unresolved" ||
     code === "morpho_fee_unavailable" ||
     code === "morpho_cleanup_failed" ||
+    code === "defi_gas_estimate_unavailable" ||
+    code === "lido_operation_reverted" ||
+    code === "lido_operation_confirmation_timeout" ||
+    code === "lido_withdrawal_reverted" ||
+    code === "lido_withdrawal_confirmation_timeout" ||
+    code === "swap_reverted" ||
+    code === "swap_confirmation_timeout" ||
     code === "token_transfer_failed" ||
     code === "fee_limit_exceeded" ||
     code === "token_read_failed" ||
@@ -138,11 +147,20 @@ function errorStatusCode(errorCode, fallback = 400) {
     errorCode === "swap_cleanup_failed" ||
     errorCode === "aave_approval_required" ||
     errorCode === "aave_fee_unavailable" ||
+    errorCode === "aave_operation_reverted" ||
+    errorCode === "aave_operation_confirmation_timeout" ||
     errorCode === "aave_cleanup_failed" ||
     errorCode === "morpho_api_failed" ||
     errorCode === "morpho_requirements_unresolved" ||
     errorCode === "morpho_fee_unavailable" ||
     errorCode === "morpho_cleanup_failed" ||
+    errorCode === "defi_gas_estimate_unavailable" ||
+    errorCode === "lido_operation_reverted" ||
+    errorCode === "lido_operation_confirmation_timeout" ||
+    errorCode === "lido_withdrawal_reverted" ||
+    errorCode === "lido_withdrawal_confirmation_timeout" ||
+    errorCode === "swap_reverted" ||
+    errorCode === "swap_confirmation_timeout" ||
     errorCode === "token_transfer_failed" ||
     errorCode === "fee_limit_exceeded" ||
     errorCode === "uniswap_api_key_missing"

package/wdk-evm-wallet/src/wdk_evm_wallet.js

@@ -41,12 +41,17 @@ const UNISWAP_EXECUTION_PROFILES = {
   },
   robinhood: {
     chainId: 4663,
-    universalRouters: { "2.0": "0x8876789976decbfcbbbe364623c63652db8c0904" },
+    // Robinhood Chain has no Universal Router 2.0 deployment - Uniswap
+    // defaults it (like Ink) to 2.1.1, and requesting "2.0" makes the Trading
+    // API return a blanket "No quotes available" for every pair on this
+    // chain. See https://blog.uniswap.org/robinhood-chain-is-live. Same
+    // contract address as before; only the version label changes.
+    universalRouters: { "2.1.1": "0x8876789976decbfcbbbe364623c63652db8c0904" },
     wrappedNative: "0x0bd7d308f8e1639fab988df18a8011f41eacad73",
-    // Robinhood's official deployment exposes the V3 stack. Asking the Trading
-    // API for undeployed V2/V4 routes can make an otherwise valid V3-only pair
-    // appear unavailable, so keep the protocol set chain-specific.
-    ammProtocols: ["V3"],
+    // Full protocol stack like ethereum/base - the earlier V3-only filter
+    // wasn't the actual blocker (see router version note above) but there's
+    // no reason to hide V2/V4 routes from the Trading API either.
+    ammProtocols: ["V2", "V3", "V4"],
     v3DirectFallback: {
       quoterV2: "0x33e885ed0ec9bf04ecfb19341582aadcb4c8a9e7",
       swapRouter02: "0xcaf681a66d020601342297493863e78c959e5cb2",
@@ -155,8 +160,20 @@ const MORPHO_MAX_LIST_LIMIT = 500;
 // two minutes is below the indexer's own aggregation noise.
 const MORPHO_DISCOVERY_CACHE_TTL_MS = 120_000;
 const MORPHO_DISCOVERY_CACHE_MAX_ENTRIES = 64;
+// DeFi routes can take a different on-chain branch between estimate time and
+// inclusion. Estimate exact final calldata immediately before signing and use
+// an explicit headroom rather than relying on the provider/WDK default.
+const DEFI_GAS_BUFFER_BPS = 13_000n;
+const MORPHO_GAS_BUFFER_BPS = DEFI_GAS_BUFFER_BPS;
+const BPS_DENOMINATOR = 10_000n;
 const morphoDiscoveryCache = new Map();
 
+function applyGasBuffer(value, bufferBps = MORPHO_GAS_BUFFER_BPS) {
+  const normalizedValue = BigInt(value);
+  const normalizedBufferBps = BigInt(bufferBps);
+  return (normalizedValue * normalizedBufferBps + BPS_DENOMINATOR - 1n) / BPS_DENOMINATOR;
+}
+
 function morphoDiscoveryCacheGet(key) {
   const entry = morphoDiscoveryCache.get(key);
   if (!entry) {
@@ -2512,12 +2529,20 @@ export class WdkEvmWalletService {
         const protocol = this.#createMorphoProtocol(account, runtimeConfig, request);
         let result;
         try {
-          result = await protocol[this.#getMorphoOperationMethods(request).sendMethod](
-            this.#buildMorphoOperationOptions(request)
-          );
+          result = await this.#sendMorphoProtocolOperation({
+            account,
+            runtimeConfig,
+            protocol,
+            request,
+          });
         } finally {
           await maybeDispose(protocol);
         }
+        await this.#waitForTransactionReceipt(runtimeConfig, result.hash, {
+          operationLabel: "Morpho operation",
+          failureCode: "morpho_operation_reverted",
+          timeoutCode: "morpho_operation_confirmation_timeout",
+        });
         const resultFee = BigInt(result?.fee || finalPlan.operationFee || 0);
         const totalFee = requirementExecution.totalFee + resultFee;
         return {
@@ -2543,6 +2568,7 @@ export class WdkEvmWalletService {
             requirementsFee: requirementExecution.totalFee.toString(),
             requirements: requirementExecution.transactions,
           },
+          confirmed: true,
         };
       } catch (error) {
         const cleanup = await this.#restoreMorphoRequirementsAfterFailedOperation({
@@ -2689,12 +2715,20 @@ export class WdkEvmWalletService {
         const protocol = this.#createMorphoProtocol(account, runtimeConfig, request);
         let result;
         try {
-          result = await protocol[this.#getMorphoOperationMethods(request).sendMethod](
-            this.#buildMorphoOperationOptions(request)
-          );
+          result = await this.#sendMorphoProtocolOperation({
+            account,
+            runtimeConfig,
+            protocol,
+            request,
+          });
         } finally {
           await maybeDispose(protocol);
         }
+        await this.#waitForTransactionReceipt(runtimeConfig, result.hash, {
+          operationLabel: "Morpho operation",
+          failureCode: "morpho_operation_reverted",
+          timeoutCode: "morpho_operation_confirmation_timeout",
+        });
         const resultFee = BigInt(result?.fee || finalPlan.operationFee || 0);
         const totalFee = requirementExecution.totalFee + resultFee;
         return {
@@ -2720,6 +2754,7 @@ export class WdkEvmWalletService {
             requirementsFee: requirementExecution.totalFee.toString(),
             requirements: requirementExecution.transactions,
           },
+          confirmed: true,
         };
       } catch (error) {
         const cleanup = await this.#restoreMorphoRequirementsAfterFailedOperation({
@@ -2856,13 +2891,25 @@ export class WdkEvmWalletService {
         const protocol = new AaveProtocolEvm(account);
         let result;
         try {
-          result = await protocol[request.operation]({
-            token: request.token,
-            amount: request.amount,
+          result = await this.#sendBufferedDefiProtocolOperation({
+            account,
+            runtimeConfig,
+            operationLabel: `Aave ${request.operation}`,
+            operation: request.operation,
+            invoke: () =>
+              protocol[request.operation]({
+                token: request.token,
+                amount: request.amount,
+              }),
           });
         } finally {
           await maybeDispose(protocol);
         }
+        await this.#waitForTransactionReceipt(runtimeConfig, result.hash, {
+          operationLabel: "Aave operation",
+          failureCode: "aave_operation_reverted",
+          timeoutCode: "aave_operation_confirmation_timeout",
+        });
         const resultFee = BigInt(result?.fee || 0);
         const totalFee = approvalExecution.totalFee + resultFee;
         return {
@@ -2891,6 +2938,7 @@ export class WdkEvmWalletService {
               ? { resetAllowanceHash: approvalExecution.resetAllowanceHash }
               : {}),
           },
+          confirmed: true,
         };
       } catch (error) {
         const cleanup = await this.#restoreAllowanceAfterFailedAaveOperation({
@@ -3172,7 +3220,19 @@ export class WdkEvmWalletService {
           );
         }
 
-        const result = await account.sendTransaction(finalPlan.operationTx);
+        const result = await this.#sendBufferedDefiTransaction({
+          account,
+          runtimeConfig,
+          from: address,
+          tx: finalPlan.operationTx,
+          operationLabel: `Lido ${request.operation}`,
+          operation: request.operation,
+        });
+        await this.#waitForTransactionReceipt(runtimeConfig, result.hash, {
+          operationLabel: "Lido operation",
+          failureCode: "lido_operation_reverted",
+          timeoutCode: "lido_operation_confirmation_timeout",
+        });
         const resultFee = BigInt(result?.fee || finalPlan.operationFee || 0);
         const totalFee = approvalExecution.totalFee + resultFee;
         return {
@@ -3201,6 +3261,7 @@ export class WdkEvmWalletService {
               ? { resetAllowanceHash: approvalExecution.resetAllowanceHash }
               : {}),
           },
+          confirmed: true,
         };
       } catch (error) {
         const cleanup = await this.#restoreAllowanceAfterFailedLidoOperation({
@@ -3323,7 +3384,19 @@ export class WdkEvmWalletService {
           );
         }
 
-        const result = await account.sendTransaction(finalPlan.operationTx);
+        const result = await this.#sendBufferedDefiTransaction({
+          account,
+          runtimeConfig,
+          from: address,
+          tx: finalPlan.operationTx,
+          operationLabel: `Lido ${request.operation}`,
+          operation: request.operation,
+        });
+        await this.#waitForTransactionReceipt(runtimeConfig, result.hash, {
+          operationLabel: "Lido withdrawal",
+          failureCode: "lido_withdrawal_reverted",
+          timeoutCode: "lido_withdrawal_confirmation_timeout",
+        });
         const resultFee = BigInt(result?.fee || finalPlan.operationFee || 0);
         const totalFee = approvalExecution.totalFee + resultFee;
         return {
@@ -3352,6 +3425,7 @@ export class WdkEvmWalletService {
               ? { resetAllowanceHash: approvalExecution.resetAllowanceHash }
               : {}),
           },
+          confirmed: true,
         };
       } catch (error) {
         const cleanup = await this.#restoreAllowanceAfterFailedLidoWithdrawal({
@@ -3584,12 +3658,23 @@ export class WdkEvmWalletService {
             })
           : finalPlan.simulation;
         this.#assertSimulationSucceeded(effectiveSimulation);
-        const { hash } = await account.sendTransaction(finalPlan.swapTx);
-        const totalFee = approvalExecution.totalFee + finalPlan.swapFee;
+        const swapResult = await this.#sendBufferedDefiTransaction({
+          account,
+          runtimeConfig,
+          from: address,
+          tx: finalPlan.swapTx,
+          operationLabel: "Velora swap",
+        });
+        await this.#waitForTransactionReceipt(runtimeConfig, swapResult.hash, {
+          operationLabel: "Velora swap",
+          failureCode: "swap_reverted",
+          timeoutCode: "swap_confirmation_timeout",
+        });
+        const totalFee = approvalExecution.totalFee + BigInt(swapResult.fee);
         const result = {
-          hash,
+          ...swapResult,
           fee: totalFee.toString(),
-          swapFee: finalPlan.swapFee.toString(),
+          swapFee: swapResult.fee,
           approvalFee: approvalExecution.totalFee.toString(),
           tokenInAmount: finalPlan.tokenInAmount.toString(),
           tokenOutAmount: finalPlan.tokenOutAmount.toString(),
@@ -3630,6 +3715,7 @@ export class WdkEvmWalletService {
           simulation: effectiveSimulation,
           swapTransaction: finalPlan.swapTransaction,
           result,
+          confirmed: true,
           source: "wdk-protocol-swap-velora-evm",
         };
       } catch (error) {
@@ -3740,12 +3826,23 @@ export class WdkEvmWalletService {
           : finalPlan.simulation;
         this.#assertSimulationSucceeded(effectiveSimulation);
 
-        const { hash } = await account.sendTransaction(finalPlan.swapTx);
-        const totalFee = approvalExecution.totalFee + finalPlan.swapFee;
+        const swapResult = await this.#sendBufferedDefiTransaction({
+          account,
+          runtimeConfig,
+          from: sourceAddress,
+          tx: finalPlan.swapTx,
+          operationLabel: "LI.FI swap",
+        });
+        await this.#waitForTransactionReceipt(runtimeConfig, swapResult.hash, {
+          operationLabel: "LI.FI swap",
+          failureCode: "swap_reverted",
+          timeoutCode: "swap_confirmation_timeout",
+        });
+        const totalFee = approvalExecution.totalFee + BigInt(swapResult.fee);
         const result = {
-          hash,
+          ...swapResult,
           fee: totalFee.toString(),
-          swapFee: finalPlan.swapFee.toString(),
+          swapFee: swapResult.fee,
           approvalFee: approvalExecution.totalFee.toString(),
           tokenInAmount: finalPlan.tokenInAmount.toString(),
           tokenOutAmount: finalPlan.tokenOutAmount.toString(),
@@ -3772,6 +3869,7 @@ export class WdkEvmWalletService {
             },
           }),
           result,
+          confirmed: true,
         };
       } catch (error) {
         const cleanup = await this.#restoreAllowanceAfterFailedSwap({
@@ -3967,14 +4065,25 @@ export class WdkEvmWalletService {
           });
           this.#assertSimulationSucceeded(simulation);
 
-          const { hash } = await account.sendTransaction(swapTx);
+          const swapResult = await this.#sendBufferedDefiTransaction({
+            account,
+            runtimeConfig,
+            from: address,
+            tx: swapTx,
+            operationLabel: "Uniswap swap",
+          });
+          await this.#waitForTransactionReceipt(runtimeConfig, swapResult.hash, {
+            operationLabel: "Uniswap swap",
+            failureCode: "swap_reverted",
+            timeoutCode: "swap_confirmation_timeout",
+          });
           swapTransaction = {
             to: swapTx.to,
             value: swapTx.value.toString(),
             dataHash: sha256Hex(swapTx.data),
           };
           result = {
-            hash,
+            ...swapResult,
             approvalFee: approvalExecution.totalFee.toString(),
             tokenInAmount: finalPlan.tokenInAmount.toString(),
             tokenOutAmount: finalPlan.tokenOutAmount.toString(),
@@ -4001,6 +4110,7 @@ export class WdkEvmWalletService {
           simulation,
           swapTransaction,
           result,
+          confirmed: Boolean(result.hash),
         };
       } catch (error) {
         const cleanup = await this.#restoreAllowanceAfterFailedSwap({
@@ -4536,6 +4646,150 @@ export class WdkEvmWalletService {
     return options;
   }
 
+  async #sendMorphoProtocolOperation({ account, runtimeConfig, protocol, request }) {
+    const methods = this.#getMorphoOperationMethods(request);
+    const originalSendTransaction = account.sendTransaction;
+    if (typeof originalSendTransaction !== "function") {
+      throw new Error("Morpho operation requires an EVM account with sendTransaction().");
+    }
+    const hadOwnSendTransaction = Object.prototype.hasOwnProperty.call(account, "sendTransaction");
+
+    // The protocol constructs the final calldata immediately before sending it.
+    // Intercept that one protocol-scoped send so the estimate and padded limit
+    // are based on the exact transaction, rather than a stale preview.
+    account.sendTransaction = async (tx) => {
+      const gas = await this.#prepareMorphoGasLimit({
+        runtimeConfig,
+        from: await account.getAddress(),
+        tx,
+        operation: request.operation,
+      });
+      const result = await originalSendTransaction.call(account, {
+        ...tx,
+        gasLimit: gas.gasLimit,
+      });
+      return {
+        ...result,
+        fee: gas.maximumFee,
+        gasEstimate: gas.gasEstimate.toString(),
+        gasLimit: gas.gasLimit.toString(),
+        gasBufferBps: MORPHO_GAS_BUFFER_BPS.toString(),
+      };
+    };
+
+    try {
+      return await protocol[methods.sendMethod](this.#buildMorphoOperationOptions(request));
+    } finally {
+      if (hadOwnSendTransaction) {
+        account.sendTransaction = originalSendTransaction;
+      } else {
+        delete account.sendTransaction;
+      }
+    }
+  }
+
+  async #prepareMorphoGasLimit({ runtimeConfig, from, tx, operation }) {
+    return this.#prepareBufferedDefiGasLimit({
+      runtimeConfig,
+      from,
+      tx,
+      operationLabel: `morpho ${operation}`,
+      unavailableCode: "morpho_gas_estimate_unavailable",
+      unavailableMessage: "Morpho gas estimate was empty. Generate a new quote before sending.",
+    });
+  }
+
+  async #prepareBufferedDefiGasLimit({
+    runtimeConfig,
+    from,
+    tx,
+    operationLabel,
+    unavailableCode = "defi_gas_estimate_unavailable",
+    unavailableMessage = "DeFi gas estimate was empty. Generate a new quote before sending.",
+  }) {
+    const gasEstimateHex = await rpcRequest(runtimeConfig.providerUrl, "eth_estimateGas", [
+      {
+        from: normalizeAddress(from, "from"),
+        to: normalizeAddress(String(tx.to || ""), "to"),
+        data: assertNonEmptyString(String(tx.data || ""), "data"),
+        value: toRpcHex(tx.value || 0),
+      },
+    ]);
+    const gasEstimate = BigInt(gasEstimateHex || "0x0");
+    if (gasEstimate <= 0n) {
+      throw createTaggedError(unavailableMessage, unavailableCode, { operation: operationLabel });
+    }
+    const gasLimit = applyGasBuffer(gasEstimate, DEFI_GAS_BUFFER_BPS);
+    const effectiveFeePerGas = await this.#getEffectiveGasPrice(runtimeConfig);
+    const maximumFee = gasLimit * effectiveFeePerGas;
+    this.#assertMaxFee(runtimeConfig, maximumFee, operationLabel);
+    return { gasEstimate, gasLimit, maximumFee };
+  }
+
+  async #sendBufferedDefiTransaction({ account, runtimeConfig, from, tx, operationLabel }) {
+    return this.#sendBufferedDefiTransactionWithSender({
+      sendTransaction: (preparedTx) => account.sendTransaction(preparedTx),
+      runtimeConfig,
+      from,
+      tx,
+      operationLabel,
+    });
+  }
+
+  async #sendBufferedDefiTransactionWithSender({
+    sendTransaction,
+    runtimeConfig,
+    from,
+    tx,
+    operationLabel,
+  }) {
+    const gas = await this.#prepareBufferedDefiGasLimit({
+      runtimeConfig,
+      from,
+      tx,
+      operationLabel,
+    });
+    const result = await sendTransaction({ ...tx, gasLimit: gas.gasLimit });
+    return {
+      ...result,
+      fee: gas.maximumFee.toString(),
+      gasEstimate: gas.gasEstimate.toString(),
+      gasLimit: gas.gasLimit.toString(),
+      gasBufferBps: DEFI_GAS_BUFFER_BPS.toString(),
+    };
+  }
+
+  async #sendBufferedDefiProtocolOperation({
+    account,
+    runtimeConfig,
+    operationLabel,
+    operation,
+    invoke,
+  }) {
+    const originalSendTransaction = account.sendTransaction;
+    if (typeof originalSendTransaction !== "function") {
+      throw new Error(`${operationLabel} requires an EVM account with sendTransaction().`);
+    }
+    const hadOwnSendTransaction = Object.prototype.hasOwnProperty.call(account, "sendTransaction");
+    account.sendTransaction = async (tx) =>
+      this.#sendBufferedDefiTransactionWithSender({
+        sendTransaction: (preparedTx) => originalSendTransaction.call(account, preparedTx),
+        runtimeConfig,
+        from: await account.getAddress(),
+        tx,
+        operationLabel: `${operationLabel} ${operation}`,
+      });
+    try {
+      return await invoke();
+    } finally {
+      if (hadOwnSendTransaction) {
+        account.sendTransaction = originalSendTransaction;
+      } else {
+        delete account.sendTransaction;
+      }
+    }
+  }
+
   async #buildMorphoOperationPlan({
     account,
     runtimeConfig,
@@ -4736,7 +4990,7 @@ export class WdkEvmWalletService {
     try {
       const quote = await protocol[methods.quoteMethod](operationOptions);
       return {
-        fee: BigInt(quote?.fee || 0),
+        fee: applyGasBuffer(BigInt(quote?.fee || 0), MORPHO_GAS_BUFFER_BPS),
         error: null,
       };
     } catch (error) {
@@ -4833,11 +5087,23 @@ export class WdkEvmWalletService {
     for (let index = 0; index < plan.requirements.transactions.length; index += 1) {
       const requirementTx = plan.requirements.transactions[index];
       const step = plan.requirements.steps[index];
-      const result = await account.sendTransaction({
+      const tx = {
         to: requirementTx.to,
         value: requirementTx.value ?? 0n,
         data: requirementTx.data,
-      });
+      };
+      // ERC-20 approval writes intentionally retain the narrow WDK path. A
+      // Morpho authorization is a protocol write, so give it the same buffer
+      // as the potentially stateful final operation.
+      const result = step?.type === "authorization"
+        ? await this.#sendBufferedDefiTransaction({
+            account,
+            runtimeConfig,
+            from: await account.getAddress(),
+            tx,
+            operationLabel: "Morpho authorization",
+          })
+        : await account.sendTransaction(tx);
       const fee = BigInt(result?.fee || 0);
       totalFee += fee;
       transactions.push({
@@ -4913,13 +5179,19 @@ export class WdkEvmWalletService {
       }
 
       for (const context of requirementExecution.authorizationContexts || []) {
-        const result = await account.sendTransaction({
+        const result = await this.#sendBufferedDefiTransaction({
+          account,
+          runtimeConfig,
+          from: await account.getAddress(),
+          operationLabel: "Morpho authorization cleanup",
+          tx: {
           to: context.contractAddress,
           value: 0n,
           data: MORPHO_AUTHORIZATION_INTERFACE.encodeFunctionData("setAuthorization", [
             context.authorized,
             false,
           ]),
+          },
         });
         cleanup.authorizations.push({
           contractAddress: context.contractAddress,
@@ -8030,13 +8302,21 @@ export class WdkEvmWalletService {
     }
   }
 
-  async #waitForTransactionReceipt(runtimeConfig, txHash) {
+  async #waitForTransactionReceipt(
+    runtimeConfig,
+    txHash,
+    {
+      operationLabel = "Approval transaction",
+      failureCode = "swap_approval_failed",
+      timeoutCode = "swap_approval_timeout",
+    } = {}
+  ) {
     for (let attempt = 0; attempt < 30; attempt += 1) {
       const receipt = await rpcRequest(runtimeConfig.providerUrl, "eth_getTransactionReceipt", [txHash]);
       if (receipt) {
         const status = String(receipt.status || "").toLowerCase();
         if (status === "0x0") {
-          throw createTaggedError("Approval transaction reverted onchain.", "swap_approval_failed", {
+          throw createTaggedError(`${operationLabel} reverted onchain.`, failureCode, {
             txHash,
             network: runtimeConfig.network,
           });
@@ -8046,8 +8326,8 @@ export class WdkEvmWalletService {
       await new Promise((resolve) => setTimeout(resolve, 1000));
     }
     throw createTaggedError(
-      "Timed out waiting for approval transaction confirmation.",
-      "swap_approval_timeout",
+      `Timed out waiting for ${operationLabel.toLowerCase()} confirmation.`,
+      timeoutCode,
       {
         txHash,
         network: runtimeConfig.network,
@@ -8057,6 +8337,8 @@ export class WdkEvmWalletService {
 }
 
 export const __testables = {
+  applyGasBuffer,
+  MORPHO_GAS_BUFFER_BPS,
   PERMIT2_ADDRESS,
   UNISWAP_SUPPORTED_CHAIN_IDS,
   UNISWAP_EXECUTION_PROFILES,