@agentlayer.tech/wallet 0.1.88 → 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.88",
+  "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.88",
+  "version": "0.1.89",
   "description": "OpenClaw plugin bridge for the AgentLayer wallet runtime.",
   "type": "module",
   "license": "SEE LICENSE IN ../../../LICENSE",

package/VERSION

@@ -1 +1 @@
-0.1.88
+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.88"
+__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
 
@@ -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,
         *,

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.88",
+  "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.88"
+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.88",
+  "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.88",
+  "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.88
+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.88",
+  "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.88",
+  "version": "0.1.89",
   "private": true,
   "type": "module",
   "description": "Separate BTC-only wallet service built on Tether WDK.",

package/wdk-evm-wallet/package.json

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