@agentlayer.tech/wallet 0.1.53 → 0.1.58

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.53",
+  "version": "0.1.58",
   "contracts": {
     "tools": [
       "agentlayer_autonomous_approve",

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

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

package/CHANGELOG.md

@@ -2,6 +2,69 @@
 
 ## Unreleased
 
+## v0.1.58 - 2026-07-01
+
+- Resolved SPL token symbol/name in `get_wallet_portfolio` via a batched,
+  concurrent Jupiter token-search lookup, so `/wallet-sol` shows tickers
+  (e.g. `USDC`) instead of raw mint addresses. The mint/token_address is
+  still returned in full and rendered shortened next to the label rather
+  than dropped. Falls back gracefully (symbol=None) when a mint isn't
+  indexed or the lookup provider is unavailable.
+  - `agent-wallet/agent_wallet/providers/jupiter.py`
+  - `agent-wallet/agent_wallet/wallet_layer/solana.py`
+  - `claude-code/plugins/agent-wallet/commands/wallet-sol.md`
+  - `codex/plugins/agent-wallet/skills/wallet-sol/SKILL.md`
+- Dropped the `/wallet-sol` source-metadata footer line (`source`,
+  `token_discovery_source`, `pricing_source`, `pricing_errors`) from the
+  rendered chat output for a more compact report.
+  - `claude-code/plugins/agent-wallet/commands/wallet-sol.md`
+  - `codex/plugins/agent-wallet/skills/wallet-sol/SKILL.md`
+
+## v0.1.57 - 2026-07-01
+
+- Added a bundled Codex `wallet-sol` skill so Codex users can render the
+  connected Solana wallet portfolio in chat the same way Claude Code's
+  `/wallet-sol` command does.
+  - `codex/plugins/agent-wallet/skills/wallet-sol/SKILL.md`
+  - `codex/plugins/agent-wallet/README.md`
+- Fixed the resident read worker (used by `get_wallet_balance` /
+  `get_wallet_portfolio`, e.g. `/wallet-sol`) decrypting the wallet's private
+  key on every read-only cold start even though it never needed it. Read-only
+  onboarding now resolves the address from the existing plaintext wallet pin
+  file once a wallet has been provisioned, instead of unsealing secrets and
+  deriving a signer just to discard it.
+  - `agent-wallet/agent_wallet/user_wallets.py`
+- Reduced `/wallet-sol` context payload by dropping the unused raw Jupiter
+  price blob (`price_raw`) from portfolio token entries.
+  - `agent-wallet/agent_wallet/wallet_layer/solana.py`
+- Parallelized Jupiter price batch fetches in `get_portfolio` instead of
+  awaiting each 20-mint batch sequentially, speeding up portfolio lookups for
+  wallets with many SPL token accounts.
+  - `agent-wallet/agent_wallet/wallet_layer/solana.py`
+- Added a background prewarm of the resident read worker at MCP server
+  startup so interpreter boot and onboarding overlap with the user issuing
+  the first read-only command instead of blocking it. Opt out with
+  `AGENT_WALLET_PREWARM_READ_WORKER=0`.
+  - `codex/plugins/agent-wallet/server.py`
+- Added idle eviction for resident read workers left over from a stale
+  config (e.g. after switching Solana network or wallet backend), bounded by
+  `AGENT_WALLET_READ_WORKER_IDLE_SECONDS` (default 10 minutes), and closed
+  resident read workers on SIGTERM in addition to the existing `atexit`
+  cleanup, since Python does not run `atexit` hooks on signal termination.
+  - `codex/plugins/agent-wallet/server.py`
+
+## v0.1.54 - 2026-06-29
+
+- Fixed Claude Code autonomous-mode slash command activation so
+  `/agentlayer-autonomous-approve` no longer relies on the model treating the
+  slash invocation itself as sufficient consent. The command now uses an
+  explicit in-command confirmation step before enabling the standing
+  permission, and both autonomous toggle commands are marked manual-only in the
+  Claude Code command metadata.
+  - `claude-code/plugins/agent-wallet/commands/agentlayer-autonomous-approve.md`
+  - `claude-code/plugins/agent-wallet/commands/agentlayer-autonomous-revoke.md`
+  - `claude-code/plugins/agent-wallet/README.md`
+
 ## v0.1.53 - 2026-06-26
 
 - Fixed Morpho vault and market quote (preview) requests timing out under the

package/README.md

@@ -86,35 +86,37 @@ openclaw plugins install clawhub:@agentlayertech/agent-wallet-plugin
 
 The ClawHub package does not replace the npm installer. `npx @agentlayer.tech/wallet install --yes` installs the local runtime, Python backend, and helper services. ClawHub only installs the OpenClaw plugin surface that points at that runtime.
 
-Or install the CLI globally:
+Or install the CLI globally for shorter commands:
 
 ```bash
 npm install -g @agentlayer.tech/wallet
 wallet install --yes
 ```
 
+> **Why install globally?** Without the global install, `wallet` is not in your `PATH` and commands like `wallet update --yes` return `zsh: command not found: wallet`. The global install adds the `wallet` binary once; after that all `wallet <cmd>` shortcuts work. If you skip the global install, prefix every command with `npx @agentlayer.tech/wallet` instead (see the Updating section below).
+
 The CLI uses a versioned runtime layout:
 
 ```bash
-~/.openclaw/agent-wallet-runtime/releases/<version>
-~/.openclaw/agent-wallet-runtime/current
+~/.openclaw/agent-wallet-runtime/releases/<version>   # immutable per-version snapshots
+~/.openclaw/agent-wallet-runtime/current              # symlink → active release
 ```
 
 On first install, `--yes` generates local runtime secrets. The installer stores `master_key` and `approval_secret` in `~/.openclaw/sealed_keys.json`; only the boot key needed to unlock that sealed bundle is written to the runtime `.env`.
 
-Useful npm CLI commands:
+Useful CLI commands (require the global install above):
 
 ```bash
-wallet status
-wallet doctor
-wallet hermes install --yes
-wallet codex install --yes
-wallet update --yes
-wallet update --yes --dry-run
-wallet rollback
+wallet status                    # show active runtime version and health
+wallet doctor                    # diagnose common config problems
+wallet update --yes              # upgrade to the latest published version
+wallet update --yes --dry-run    # preview the upgrade without applying it
+wallet rollback                  # revert to the previous release
+wallet hermes install --yes      # (re)connect Hermes to the current runtime
+wallet codex install --yes       # (re)connect Codex to the current runtime
 ```
 
-`wallet update --yes` delegates to the latest published npm package and reuses shared Python and Node dependency snapshots when possible. Use `wallet update --yes --dry-run` to inspect the target version and dependency plan before switching `current`.
+`wallet update --yes` fetches the latest npm package, installs it under `releases/<version>`, and flips the `current` symlink. Python and Node dependency snapshots are reused when the dependency fingerprint has not changed, so subsequent updates are fast. All frameworks that read from `current/` (Claude Code, Codex, Hermes) pick up the new code automatically on their next session start; OpenClaw requires a gateway restart to reload its TypeScript extension.
 
 ## Native OpenClaw plugin installs
 

package/VERSION

@@ -1 +1 @@
-0.1.53
+0.1.58

package/agent-wallet/.env.example

@@ -43,6 +43,7 @@ SOLANA_AGENT_KEYPAIR_PATH=
 JUPITER_API_BASE_URL=https://lite-api.jup.ag/swap/v1
 JUPITER_ULTRA_API_BASE_URL=https://lite-api.jup.ag/ultra/v1
 JUPITER_PRICE_API_BASE_URL=https://lite-api.jup.ag/price/v3
+JUPITER_TOKEN_SEARCH_API_BASE_URL=https://lite-api.jup.ag/tokens/v2
 JUPITER_API_KEY=
 
 # LI.FI cross-chain routing. API key is optional for basic read-only quote/status calls.

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

package/agent-wallet/agent_wallet/config.py

@@ -48,6 +48,7 @@ class Settings(BaseSettings):
     jupiter_swap_v2_api_base_url: str = "https://api.jup.ag/swap/v2"
     jupiter_ultra_api_base_url: str = "https://lite-api.jup.ag/ultra/v1"
     jupiter_price_api_base_url: str = "https://lite-api.jup.ag/price/v3"
+    jupiter_token_search_api_base_url: str = "https://lite-api.jup.ag/tokens/v2"
     jupiter_api_key: str = ""
     lifi_api_base_url: str = "https://li.quest/v1"
     lifi_api_key: str = ""
@@ -74,6 +75,14 @@ class Settings(BaseSettings):
 settings = Settings()
 
 
+def reload_settings() -> Settings:
+    """Reload settings from the current environment without changing object identity."""
+    refreshed = Settings()
+    for field_name in Settings.model_fields:
+        setattr(settings, field_name, getattr(refreshed, field_name))
+    return settings
+
+
 def normalize_solana_network(network: str | None) -> str:
     """Canonicalize supported Solana network names and reject test clusters."""
     normalized = str(network or "").strip().lower() or "mainnet"

package/agent-wallet/agent_wallet/openclaw_cli.py

@@ -33,6 +33,12 @@ def _parse_csv(value: Any) -> str:
 
 
 SECRET_CONFIG_KEYS = {"privateKey", "masterKey", "approvalSecret"}
+READ_ONLY_WORKER_TOOLS = frozenset(
+    {
+        "get_wallet_balance",
+        "get_wallet_portfolio",
+    }
+)
 
 
 def _reject_secret_config_json(config: dict[str, Any]) -> None:
@@ -117,6 +123,9 @@ def _apply_config_overrides(config: dict[str, Any]) -> None:
         if not allow_override and os.getenv(env_name, "").strip():
             continue
         os.environ[env_name] = text
+    from agent_wallet.config import reload_settings
+
+    reload_settings()
 
 
 def _load_json(raw: str | None, default: dict[str, Any] | None = None) -> dict[str, Any]:
@@ -138,10 +147,23 @@ def _read_stdin_secret(field_name: str) -> str:
 async def _run_onboard(user_id: str, config: dict[str, Any]) -> dict[str, Any]:
     from agent_wallet.openclaw_runtime import onboard_openclaw_user_wallet
 
-    context = onboard_openclaw_user_wallet(
+    context = _build_runtime_context(user_id, config)
+    return context.serializable_bundle()
+
+
+def _build_runtime_context(
+    user_id: str,
+    config: dict[str, Any],
+    *,
+    read_only: bool = False,
+) -> Any:
+    from agent_wallet.openclaw_runtime import onboard_openclaw_user_wallet
+
+    return onboard_openclaw_user_wallet(
         user_id,
         backend=config.get("backend"),
         sign_only=config.get("signOnly"),
+        read_only=read_only,
         network=config.get("network"),
         rpc_url=config.get("rpcUrl"),
         wdk_btc_service_url=config.get("wdkBtcServiceUrl"),
@@ -151,7 +173,6 @@ async def _run_onboard(user_id: str, config: dict[str, Any]) -> dict[str, Any]:
         wdk_evm_wallet_id=config.get("wdkEvmWalletId"),
         wdk_evm_account_index=config.get("wdkEvmAccountIndex"),
     )
-    return context.serializable_bundle()
 
 
 async def _run_invoke(
@@ -160,21 +181,7 @@ async def _run_invoke(
     arguments: dict[str, Any],
     config: dict[str, Any],
 ) -> dict[str, Any]:
-    from agent_wallet.openclaw_runtime import onboard_openclaw_user_wallet
-
-    context = onboard_openclaw_user_wallet(
-        user_id,
-        backend=config.get("backend"),
-        sign_only=config.get("signOnly"),
-        network=config.get("network"),
-        rpc_url=config.get("rpcUrl"),
-        wdk_btc_service_url=config.get("wdkBtcServiceUrl"),
-        wdk_btc_wallet_id=config.get("wdkBtcWalletId"),
-        wdk_btc_account_index=config.get("wdkBtcAccountIndex"),
-        wdk_evm_service_url=config.get("wdkEvmServiceUrl"),
-        wdk_evm_wallet_id=config.get("wdkEvmWalletId"),
-        wdk_evm_account_index=config.get("wdkEvmAccountIndex"),
-    )
+    context = _build_runtime_context(user_id, config)
     result = await context.adapter.invoke(tool_name, arguments)
     return result.model_dump()
 
@@ -188,21 +195,7 @@ async def _run_issue_approval(
     mainnet_confirmed: bool = False,
     ttl_seconds: int | None = None,
 ) -> dict[str, Any]:
-    from agent_wallet.openclaw_runtime import onboard_openclaw_user_wallet
-
-    context = onboard_openclaw_user_wallet(
-        user_id,
-        backend=config.get("backend"),
-        sign_only=config.get("signOnly"),
-        network=config.get("network"),
-        rpc_url=config.get("rpcUrl"),
-        wdk_btc_service_url=config.get("wdkBtcServiceUrl"),
-        wdk_btc_wallet_id=config.get("wdkBtcWalletId"),
-        wdk_btc_account_index=config.get("wdkBtcAccountIndex"),
-        wdk_evm_service_url=config.get("wdkEvmServiceUrl"),
-        wdk_evm_wallet_id=config.get("wdkEvmWalletId"),
-        wdk_evm_account_index=config.get("wdkEvmAccountIndex"),
-    )
+    context = _build_runtime_context(user_id, config)
     token = context.issue_execute_approval(
         tool_name=tool_name,
         confirmation_summary=summary,
@@ -250,6 +243,69 @@ def _run_autonomous_permission(action: str, scope: str) -> dict[str, Any]:
     raise WalletBackendError("action must be approve, revoke, or status.")
 
 
+def _error_payload_for_exception(exc: Exception) -> dict[str, Any]:
+    payload: dict[str, Any] = {"ok": False, "error": str(exc)}
+    if isinstance(exc, WalletBackendError):
+        if exc.code:
+            payload["code"] = exc.code
+        if exc.details is not None:
+            payload["details"] = exc.details
+    return payload
+
+
+async def _run_read_worker_tool(context: Any, request: dict[str, Any]) -> dict[str, Any]:
+    tool_name = str(request.get("tool") or "").strip()
+    if tool_name not in READ_ONLY_WORKER_TOOLS:
+        raise WalletBackendError(
+            f"read-worker only allows read-only tools: {', '.join(sorted(READ_ONLY_WORKER_TOOLS))}."
+        )
+    arguments = request.get("arguments") or {}
+    if not isinstance(arguments, dict):
+        raise WalletBackendError("read-worker request arguments must be a JSON object.")
+    result = await context.adapter.invoke(tool_name, arguments)
+    return result.model_dump()
+
+
+async def _serve_read_worker(user_id: str, config: dict[str, Any]) -> int:
+    context = _build_runtime_context(user_id, config, read_only=True)
+    while True:
+        line = sys.stdin.readline()
+        if not line:
+            break
+        text = line.strip()
+        if not text:
+            continue
+        request_id: str | None = None
+        try:
+            request = _load_json(text)
+            request_id = str(request.get("id") or "").strip() or None
+            if request.get("op") == "shutdown":
+                print(json.dumps({"id": request_id, "ok": True, "stopped": True}), flush=True)
+                break
+            payload = await _run_read_worker_tool(context, request)
+            print(
+                json.dumps(
+                    {
+                        "id": request_id,
+                        "ok": True,
+                        "payload": payload,
+                    }
+                ),
+                flush=True,
+            )
+        except Exception as exc:
+            print(
+                json.dumps(
+                    {
+                        "id": request_id,
+                        **_error_payload_for_exception(exc),
+                    }
+                ),
+                flush=True,
+            )
+    return 0
+
+
 async def _run_btc_wallet_get(user_id: str, config: dict[str, Any]) -> dict[str, Any]:
     from agent_wallet.btc_user_wallets import get_user_btc_wallet_binding
 
@@ -522,6 +578,10 @@ def main() -> int:
     evm_lock_parser.add_argument("--user-id", required=True)
     evm_lock_parser.add_argument("--config-json", default="{}")
 
+    read_worker_parser = subparsers.add_parser("read-worker")
+    read_worker_parser.add_argument("--user-id", required=True)
+    read_worker_parser.add_argument("--config-json", default="{}")
+
     args = parser.parse_args()
 
     try:
@@ -643,6 +703,8 @@ def main() -> int:
             )
         elif args.command == "evm-wallet-lock":
             payload = asyncio.run(_run_evm_wallet_lock(args.user_id, config))
+        elif args.command == "read-worker":
+            return asyncio.run(_serve_read_worker(args.user_id, config))
         else:
             payload = asyncio.run(
                 _run_invoke(
@@ -662,13 +724,7 @@ def main() -> int:
                 backend=str(locals().get("config", {}).get("backend", "") or ""),
                 ok=False,
             )
-        error_payload: dict[str, Any] = {"ok": False, "error": str(exc)}
-        if isinstance(exc, WalletBackendError):
-            if exc.code:
-                error_payload["code"] = exc.code
-            if exc.details is not None:
-                error_payload["details"] = exc.details
-        print(json.dumps(error_payload), file=sys.stderr)
+        print(json.dumps(_error_payload_for_exception(exc)), file=sys.stderr)
         return 1
 
     if getattr(args, "command", "") == "invoke":

package/agent-wallet/agent_wallet/openclaw_runtime.py

@@ -87,6 +87,7 @@ def onboard_openclaw_user_wallet(
     *,
     backend: str | None = None,
     sign_only: bool | None = None,
+    read_only: bool = False,
     network: str | None = None,
     rpc_url: str | None = None,
     wdk_btc_service_url: str | None = None,
@@ -98,6 +99,9 @@ def onboard_openclaw_user_wallet(
 ) -> OpenClawWalletRuntimeContext:
     """Provision and assemble a runtime-ready wallet context for one OpenClaw user."""
     backend_name = str(backend or settings.agent_wallet_backend).strip().lower()
+    effective_sign_only = True if read_only else (
+        settings.agent_wallet_sign_only if sign_only is None else sign_only
+    )
     if backend_name in {"wdk_btc_local", "wdk-btc-local", "btc_local", "btc-local"}:
         service_url = str(wdk_btc_service_url or settings.wdk_btc_service_url).strip()
         account_index = (
@@ -133,7 +137,7 @@ def onboard_openclaw_user_wallet(
             wallet_id=wallet_id,
             network=effective_network,
             account_index=account_index,
-            sign_only=settings.agent_wallet_sign_only if sign_only is None else sign_only,
+            sign_only=effective_sign_only,
             address=str(address_payload.get("address") or "").strip() or None,
         )
         wallet_info = {
@@ -188,7 +192,7 @@ def onboard_openclaw_user_wallet(
             wallet_id=wallet_id,
             network=effective_network,
             account_index=account_index,
-            sign_only=settings.agent_wallet_sign_only if sign_only is None else sign_only,
+            sign_only=effective_sign_only,
             address=resolved_address or None,
         )
         wallet_info = {
@@ -213,7 +217,8 @@ def onboard_openclaw_user_wallet(
 
     backend, wallet_info, created_now = create_openclaw_solana_backend(
         user_id,
-        sign_only=sign_only,
+        sign_only=effective_sign_only,
+        read_only=read_only,
         network=network,
         rpc_url=rpc_url,
     )

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

@@ -483,3 +483,37 @@ async def fetch_prices(
     if not isinstance(data, dict):
         raise ProviderError("jupiter", "Unexpected price response from Jupiter.")
     return data
+
+
+async def fetch_token_metadata(*, mints: list[str]) -> dict[str, dict[str, Any]]:
+    """Look up token symbol/name for a batch of mints via Jupiter's token
+    search API. Keyed by mint address; mints Jupiter doesn't index (very new
+    or illiquid tokens) are simply absent from the result rather than
+    raising, since this is display-only enrichment on top of the price data.
+    """
+    if not mints:
+        return {}
+    client = get_client()
+    params = {"query": ",".join(mints)}
+    response = await client.get(
+        f"{settings.jupiter_token_search_api_base_url.rstrip('/')}/search",
+        params=params,
+        headers=_headers(),
+    )
+    if response.status_code != 200:
+        raise ProviderError("jupiter", f"HTTP {response.status_code}: {response.text[:300]}")
+    data = response.json()
+    if not isinstance(data, list):
+        raise ProviderError("jupiter", "Unexpected token search response from Jupiter.")
+    result: dict[str, dict[str, Any]] = {}
+    for item in data:
+        if not isinstance(item, dict):
+            continue
+        mint = str(item.get("id") or "").strip()
+        if not mint:
+            continue
+        result[mint] = {
+            "symbol": item.get("symbol"),
+            "name": item.get("name"),
+        }
+    return result

package/agent-wallet/agent_wallet/user_wallets.py

@@ -147,10 +147,31 @@ def _load_user_wallet_secret_material(
     )
 
 
-def ensure_user_solana_wallet(user_id: str, network: str | None = None) -> dict[str, str]:
+def ensure_user_solana_wallet(
+    user_id: str,
+    network: str | None = None,
+    *,
+    read_only: bool = False,
+) -> dict[str, str]:
     """Provision a per-user Solana wallet if it does not exist yet."""
     effective_network = _resolve_effective_network(network)
     path = resolve_user_wallet_path(user_id, network=effective_network)
+    if read_only and path.exists():
+        # Read-only callers only need the address. The pin file already stores
+        # it in plaintext, so skip decrypting the wallet secret material and
+        # deriving the signer entirely rather than paying for a KDF unseal +
+        # keypair derivation just to read (and immediately discard) a private
+        # key. Falls through to the full decrypt path below if no pin exists
+        # yet (e.g. a wallet file predating pin files).
+        pin = load_wallet_pin(path)
+        if pin is not None and pin["network"] == effective_network:
+            return {
+                "user_id": user_id,
+                "address": pin["address"],
+                "path": str(path),
+                "storage_format": "encrypted",
+                "key_scope": "pinned-address-only",
+            }
     if path.exists():
         secret_material, storage_format, key_scope = _load_user_wallet_secret_material(
             path,
@@ -362,6 +383,7 @@ def create_openclaw_solana_backend(
     user_id: str,
     *,
     sign_only: bool | None = None,
+    read_only: bool = False,
     network: str | None = None,
     rpc_url: str | None = None,
 ) -> tuple[SolanaWalletBackend, dict[str, str], bool]:
@@ -396,6 +418,11 @@ def create_openclaw_solana_backend(
         raise WalletBackendError(
             "Configured Solana publicKey does not match the signer derived from keypairPath/runtime secret."
         )
+    effective_sign_only = True if read_only else (
+        settings.agent_wallet_sign_only if sign_only is None else sign_only
+    )
+    if read_only:
+        signer = None
 
     rpc_config = resolve_runtime_solana_rpc_config(
         effective_network,
@@ -411,7 +438,7 @@ def create_openclaw_solana_backend(
             network=effective_network,
             signer=signer,
             address=resolved_address or None,
-            sign_only=settings.agent_wallet_sign_only if sign_only is None else sign_only,
+            sign_only=effective_sign_only,
             rpc_provider_mode=str(rpc_config["mode"]),
             rpc_provider=str(rpc_config["provider"]),
             rpc_transport=str(rpc_config["transport"]),
@@ -429,11 +456,27 @@ def create_openclaw_solana_backend(
 
     wallet_path = resolve_user_wallet_path(user_id, network=effective_network)
     created_now = not wallet_path.exists()
+    wallet_info = ensure_user_solana_wallet(user_id, network=effective_network, read_only=read_only)
+    if read_only:
+        backend = SolanaWalletBackend(
+            rpc_url=rpc_config["rpc_urls"],
+            commitment=settings.solana_commitment,
+            network=effective_network,
+            signer=None,
+            address=wallet_info["address"] or None,
+            sign_only=effective_sign_only,
+            rpc_provider_mode=str(rpc_config["mode"]),
+            rpc_provider=str(rpc_config["provider"]),
+            rpc_transport=str(rpc_config["transport"]),
+            swap_provider=str(swap_config["provider"]),
+            swap_transport=str(swap_config["transport"]),
+        )
+        return backend, wallet_info, created_now
+
     backend = create_wallet_backend_for_user(
         user_id,
         sign_only=sign_only,
         network=effective_network,
         rpc_url=rpc_url,
     )
-    wallet_info = ensure_user_solana_wallet(user_id, network=effective_network)
     return backend, wallet_info, created_now

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

@@ -339,17 +339,37 @@ class SolanaWalletBackend(AgentWalletBackend):
 
         price_data_by_mint: dict[str, dict[str, Any]] = {}
         price_errors: list[str] = []
-        for index in range(0, len(mints), 20):
-            batch = mints[index : index + 20]
-            try:
-                price_data = await jupiter.fetch_prices(mints=batch)
-            except ProviderError as exc:
-                price_errors.append(str(exc))
+        token_metadata_by_mint: dict[str, dict[str, Any]] = {}
+        token_metadata_errors: list[str] = []
+        price_batches = [mints[index : index + 20] for index in range(0, len(mints), 20)]
+        # Independent HTTP calls against a shared async client, so fetch every
+        # price batch AND every token symbol/name lookup batch concurrently
+        # instead of paying sequential round trips for wallets with many SPL
+        # token accounts.
+        all_results = await asyncio.gather(
+            *(jupiter.fetch_prices(mints=batch) for batch in price_batches),
+            *(jupiter.fetch_token_metadata(mints=batch) for batch in price_batches),
+            return_exceptions=True,
+        )
+        batch_results = all_results[: len(price_batches)]
+        metadata_batch_results = all_results[len(price_batches) :]
+        for batch, result in zip(price_batches, batch_results):
+            if isinstance(result, ProviderError):
+                price_errors.append(str(result))
                 continue
+            if isinstance(result, BaseException):
+                raise result
             for mint in batch:
-                entry = _jupiter_price_entry(price_data, mint)
+                entry = _jupiter_price_entry(result, mint)
                 if entry is not None:
                     price_data_by_mint[mint] = entry
+        for result in metadata_batch_results:
+            if isinstance(result, ProviderError):
+                token_metadata_errors.append(str(result))
+                continue
+            if isinstance(result, BaseException):
+                raise result
+            token_metadata_by_mint.update(result)
 
         native_price = _jupiter_usd_price(price_data_by_mint.get(NATIVE_SOL_MINT))
         native_amount = _coerce_decimal(native_balance.get("balance_native"))
@@ -379,13 +399,15 @@ class SolanaWalletBackend(AgentWalletBackend):
             if value is not None:
                 total_value += value
                 priced_asset_count += 1
+            metadata = token_metadata_by_mint.get(mint) or {}
             enriched_tokens.append(
                 {
                     **token,
+                    "symbol": metadata.get("symbol"),
+                    "name": metadata.get("name"),
                     "price_usd": str(price) if price is not None else None,
                     "value_usd": _format_decimal(value),
                     "pricing_source": "jupiter-price" if price is not None else None,
-                    "price_raw": price_data_by_mint.get(mint),
                 }
             )
 
@@ -410,6 +432,8 @@ class SolanaWalletBackend(AgentWalletBackend):
             {
                 "asset_type": "spl-token",
                 "mint": token.get("mint"),
+                "symbol": token.get("symbol"),
+                "name": token.get("name"),
                 "token_account": token.get("token_account"),
                 "amount_raw": token.get("amount_raw"),
                 "amount_ui": token.get("amount_ui"),
@@ -442,6 +466,8 @@ class SolanaWalletBackend(AgentWalletBackend):
             "total_value_usd": formatted_total_value,
             "pricing_source": "jupiter-price" if price_data_by_mint else None,
             "pricing_errors": price_errors,
+            "token_metadata_source": "jupiter-token-search" if token_metadata_by_mint else None,
+            "token_metadata_errors": token_metadata_errors,
             "token_discovery_source": "solana-rpc",
             "source": "solana-rpc+jupiter-price",
         }

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.53",
+  "version": "0.1.58",
   "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.53"
+version = "0.1.58"
 description = "Plugin-friendly wallet backend for OpenClaw agents"
 requires-python = ">=3.10"
 dependencies = [