@agentlayer.tech/wallet 0.1.55 → 0.1.64

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

package/bin/openclaw-agent-wallet.mjs

@@ -23,6 +23,7 @@ const TELEMETRY_FLUSH_THROTTLE_SECONDS = 20;
 const TELEMETRY_FORCE_LINES = 25;
 const TELEMETRY_MAX_EVENTS_PER_FLUSH = 100;
 const TELEMETRY_HTTP_TIMEOUT_MS = 1500;
+const KEYSTORE_BRIDGE_TIMEOUT_MS = 30000;
 
 function printHelp() {
   console.log(`openclaw-agent-wallet
@@ -148,6 +149,11 @@ function telemetrySource(env = process.env) {
     : "global_cli";
 }
 
+function positiveIntEnv(name, fallback, env = process.env) {
+  const parsed = Number.parseInt(String(env[name] || ""), 10);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : fallback;
+}
+
 function telemetryGatewayUrl(env = process.env) {
   return String(env.PROVIDER_GATEWAY_URL || DEFAULT_PROVIDER_GATEWAY_URL).trim().replace(/\/+$/, "");
 }
@@ -900,6 +906,60 @@ function ensureBootKeyFile(env = process.env) {
   return { path: keyFile, status: "created" };
 }
 
+// Read the boot key from the OS keystore via the current runtime's Python
+// (best-effort, "" on any failure). Lets a re-install after the runtime migration
+// — which moves the key into the keystore and deletes every plaintext copy — still
+// resolve the existing boot key instead of refusing to touch sealed secrets.
+function readBootKeyFromKeystore(env = process.env) {
+  const runtimeRoot = resolvedCurrentRuntimeRoot(env);
+  if (!runtimeRoot) return "";
+  const py = resolveVenvPython(runtimeRoot);
+  if (!py) return "";
+  try {
+    const res = spawnSync(
+      py,
+      ["-c", "from agent_wallet.config import read_boot_key_from_keystore as r; print(r())"],
+      {
+        cwd: path.join(runtimeRoot, "agent-wallet"),
+        encoding: "utf8",
+        timeout: positiveIntEnv("AGENT_WALLET_KEYSTORE_BRIDGE_TIMEOUT_MS", KEYSTORE_BRIDGE_TIMEOUT_MS, env),
+        env: { ...env, OPENCLAW_HOME: resolveOpenclawHome(env) },
+      },
+    );
+    if ((res.status ?? 1) !== 0) return "";
+    return String(res.stdout || "").trim();
+  } catch {
+    return "";
+  }
+}
+
+// Provision the boot key into the OS keystore via the freshly installed runtime's
+// Python. Returns true only when the import stored AND verified the key, so the
+// caller may safely drop the plaintext .env copy. Best-effort: false on any failure
+// (e.g. no usable keystore), in which case the caller keeps the legacy .env write.
+function provisionBootKeyToKeystore(releaseRoot, env, bootKey) {
+  const key = String(bootKey || "").trim();
+  if (!key) return false;
+  const py = resolveVenvPython(releaseRoot);
+  if (!py) return false;
+  try {
+    const res = spawnSync(
+      py,
+      ["-m", "agent_wallet.openclaw_cli", "boot-key-import", "--key-stdin"],
+      {
+        cwd: path.join(releaseRoot, "agent-wallet"),
+        input: key,
+        encoding: "utf8",
+        timeout: positiveIntEnv("AGENT_WALLET_KEYSTORE_BRIDGE_TIMEOUT_MS", KEYSTORE_BRIDGE_TIMEOUT_MS, env),
+        env: { ...env, OPENCLAW_HOME: resolveOpenclawHome(env) },
+      },
+    );
+    return (res.status ?? 1) === 0;
+  } catch {
+    return false;
+  }
+}
+
 function resolveVenvPython(releaseRoot) {
   const candidates = [
     path.join(releaseRoot, "agent-wallet", ".venv", "bin", "python"),
@@ -1169,7 +1229,8 @@ function buildInstallerEnv(args) {
     const existingBootKey =
       resolveBootKeyFromFile(env) ||
       readTextIfExists(defaultBootKeyFile(env)).trim() ||
-      currentBootKey(env);
+      currentBootKey(env) ||
+      readBootKeyFromKeystore(env);
     if (existingBootKey) {
       env.AGENT_WALLET_BOOT_KEY = existingBootKey;
     }
@@ -1318,9 +1379,17 @@ function runInstall(args, { commandName = "install" } = {}) {
   }
 
   if (env.AGENT_WALLET_BOOT_KEY) {
-    envFileSet(path.join(releaseRoot, "agent-wallet", ".env"), {
-      AGENT_WALLET_BOOT_KEY: env.AGENT_WALLET_BOOT_KEY,
-    });
+    const envPath = path.join(releaseRoot, "agent-wallet", ".env");
+    // Prefer the OS keystore: provision the boot key there and keep the plaintext
+    // out of the release .env entirely. Only fall back to the legacy .env write when
+    // no keystore round-trip is possible, so the runtime can still resolve the key.
+    if (provisionBootKeyToKeystore(releaseRoot, env, env.AGENT_WALLET_BOOT_KEY)) {
+      envFileUnset(envPath, ["AGENT_WALLET_BOOT_KEY"]);
+    } else {
+      envFileSet(envPath, {
+        AGENT_WALLET_BOOT_KEY: env.AGENT_WALLET_BOOT_KEY,
+      });
+    }
   }
 
   const pythonInfo = activePythonRuntimeInfo(env);

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

@@ -1,7 +1,7 @@
 {
   "name": "agent-wallet",
   "displayName": "Agent Wallet",
-  "version": "0.1.55",
+  "version": "0.1.64",
   "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/claude-code/plugins/agent-wallet/commands/wallet-sol.md

@@ -1,17 +1,15 @@
 ---
-description: Show the connected Solana wallet overview directly in chat.
-allowed-tools: mcp__agent_wallet__get_wallet_overview
+description: Show the connected Solana wallet portfolio directly in chat.
+allowed-tools: mcp__agent_wallet__get_wallet_portfolio
 disable-model-invocation: true
 ---
 
-Show the connected Solana wallet overview directly in chat.
+Show the connected Solana wallet portfolio directly in chat.
 
-1. Call `get_wallet_overview` with:
+1. Call `get_wallet_portfolio` with:
 
 ```json
-{
-  "backend": "solana"
-}
+{}
 ```
 
 2. Format the response as a compact wallet report:
@@ -21,16 +19,12 @@ Show the connected Solana wallet overview directly in chat.
 - render a Markdown table with columns: `Asset | Type | Amount | USD Value`
 - use `assets` when present
 - for each asset row, prefer:
-  - asset label: `symbol`, then `mint`, then `token_address`, then `asset_type`
+  - asset label: `symbol`, then `name`, then `mint`, then `token_address`, then `asset_type`
+  - when the label came from `symbol`/`name` (not the mint/token_address itself) and a `mint` or `token_address` is present, append it shortened in parentheses next to the label as `first6…last4` (e.g. `USDC (EPjFWd…TDt1v)`) — keep the contract visible but compact, never show it twice
   - amount: `amount_ui`, then `balance_ui`, then `balance_native`, then `amount_raw`
   - usd value: `value_usd`, then `balance_usd`
 - omit zero-value rows only when both the amount and USD value are clearly zero
 - if no asset rows are available, still report the native balance summary in prose
+- do not include source metadata lines or footer fields such as `source`, `token_discovery_source`, `pricing_source`, or `pricing_errors`
 
-3. After the table, add one short metadata line with any available sources:
-
-- `source`
-- `token_discovery_source`
-- `pricing_source`
-
-4. Do not suggest transfers, swaps, or other write actions unless the user explicitly asks for them.
+3. Do not suggest transfers, swaps, or other write actions unless the user explicitly asks for them.

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

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

package/codex/plugins/agent-wallet/README.md

@@ -21,6 +21,8 @@ Primary design rules:
 - session wallet selection with `set_wallet_backend`
 - EVM network selection with `set_evm_network`
 - auto-managed approval binding for `preview -> execute` write flows
+- bundled Codex skills, including `wallet-sol` for showing the Solana wallet
+  portfolio directly in chat
 
 ## Runtime requirements
 
@@ -28,6 +30,13 @@ Primary design rules:
 - keep the local wallet files and `~/.openclaw/sealed_keys.json` in place
 - use `wallet codex install --yes` to install this plugin into Codex
 
+## Bundled skill
+
+After `wallet codex install --yes` and a Codex restart, the plugin ships a
+bundled `wallet-sol` skill. In Codex you can invoke it from the slash menu or
+explicitly as `$wallet-sol` to render the connected Solana wallet portfolio as a
+compact chat table.
+
 ## Path resolution
 
 The bridge resolves the wallet runtime from: