@agentlayer.tech/wallet 0.1.103 → 0.1.106

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

@@ -65,11 +65,36 @@ def _normalize_base_url(value: str) -> str:
     if not text:
         raise WalletBackendError("WDK EVM service URL is not configured.")
     parsed = urlparse(text)
+    if parsed.scheme == "unix":
+        if not parsed.path:
+            raise WalletBackendError("WDK EVM unix socket URL must include a path.")
+        return text
     if parsed.scheme not in {"http", "https"} or parsed.hostname not in LOCAL_WDK_EVM_HOSTS:
         raise WalletBackendError("WDK EVM service URL must point to a localhost HTTP endpoint.")
     return text.rstrip("/")
 
 
+def _httpx_target(base_url: str, path: str) -> tuple[str, dict[str, Any]]:
+    """Return (url, extra_httpx_client_kwargs) for either transport."""
+    parsed = urlparse(base_url)
+    if parsed.scheme == "unix":
+        return (
+            f"http://wdk-evm-wallet.local{path}",
+            {"transport": httpx.HTTPTransport(uds=parsed.path)},
+        )
+    return (f"{base_url}{path}", {})
+
+
+def _async_httpx_target(base_url: str, path: str) -> tuple[str, dict[str, Any]]:
+    parsed = urlparse(base_url)
+    if parsed.scheme == "unix":
+        return (
+            f"http://wdk-evm-wallet.local{path}",
+            {"transport": httpx.AsyncHTTPTransport(uds=parsed.path)},
+        )
+    return (f"{base_url}{path}", {})
+
+
 def _resolve_local_token_path() -> Path:
     configured = os.getenv("WDK_EVM_LOCAL_TOKEN_PATH", "").strip()
     if configured:
@@ -195,16 +220,16 @@ class WdkEvmLocalClient:
         return {**payload, "password": password}
 
     async def post(self, path: str, payload: dict[str, Any]) -> dict[str, Any]:
+        url, transport_kwargs = _async_httpx_target(self.base_url, path)
         try:
             async with httpx.AsyncClient(
                 timeout=_timeout_for_path(path),
                 headers=self._headers,
                 follow_redirects=False,
                 trust_env=False,
+                **transport_kwargs,
             ) as client:
-                response = await client.post(
-                    f"{self.base_url}{path}", json=self._with_credentials(payload)
-                )
+                response = await client.post(url, json=self._with_credentials(payload))
         except httpx.TimeoutException as exc:
             raise WalletBackendError(
                 "wdk-evm-wallet request timed out.",
@@ -220,14 +245,16 @@ class WdkEvmLocalClient:
         return _unwrap_payload(response)
 
     async def get(self, path: str) -> dict[str, Any]:
+        url, transport_kwargs = _async_httpx_target(self.base_url, path)
         try:
             async with httpx.AsyncClient(
                 timeout=_timeout_for_path(path),
                 headers=self._headers,
                 follow_redirects=False,
                 trust_env=False,
+                **transport_kwargs,
             ) as client:
-                response = await client.get(f"{self.base_url}{path}")
+                response = await client.get(url)
         except httpx.TimeoutException as exc:
             raise WalletBackendError(
                 "wdk-evm-wallet request timed out.",
@@ -243,16 +270,16 @@ class WdkEvmLocalClient:
         return _unwrap_payload(response)
 
     def post_sync(self, path: str, payload: dict[str, Any]) -> dict[str, Any]:
+        url, transport_kwargs = _httpx_target(self.base_url, path)
         try:
             with httpx.Client(
                 timeout=_timeout_for_path(path),
                 headers=self._headers,
                 follow_redirects=False,
                 trust_env=False,
+                **transport_kwargs,
             ) as client:
-                response = client.post(
-                    f"{self.base_url}{path}", json=self._with_credentials(payload)
-                )
+                response = client.post(url, json=self._with_credentials(payload))
         except httpx.TimeoutException as exc:
             raise WalletBackendError(
                 "wdk-evm-wallet request timed out.",
@@ -268,14 +295,16 @@ class WdkEvmLocalClient:
         return _unwrap_payload(response)
 
     def get_sync(self, path: str) -> dict[str, Any]:
+        url, transport_kwargs = _httpx_target(self.base_url, path)
         try:
             with httpx.Client(
                 timeout=_timeout_for_path(path),
                 headers=self._headers,
                 follow_redirects=False,
                 trust_env=False,
+                **transport_kwargs,
             ) as client:
-                response = client.get(f"{self.base_url}{path}")
+                response = client.get(url)
         except httpx.TimeoutException as exc:
             raise WalletBackendError(
                 "wdk-evm-wallet request timed out.",
@@ -291,14 +320,16 @@ class WdkEvmLocalClient:
         return _unwrap_payload(response)
 
     def list_wallets_sync(self) -> list[dict[str, Any]]:
+        url, transport_kwargs = _httpx_target(self.base_url, "/v1/evm/wallets")
         try:
             with httpx.Client(
                 timeout=_timeout_for_path("/v1/evm/wallets"),
                 headers=self._headers,
                 follow_redirects=False,
                 trust_env=False,
+                **transport_kwargs,
             ) as client:
-                response = client.get(f"{self.base_url}/v1/evm/wallets")
+                response = client.get(url)
         except httpx.TimeoutException as exc:
             raise WalletBackendError(
                 "wdk-evm-wallet request timed out.",

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

@@ -2,16 +2,19 @@
 
 from __future__ import annotations
 
+import os
 from pathlib import Path
 
 from agent_wallet.bootstrap import ensure_solana_wallet_ready, ensure_wallet_pin
 from agent_wallet.encrypted_storage import load_wallet_secret_material
 from agent_wallet.config import (
     normalize_btc_network,
+    normalize_evm_network,
     normalize_solana_network,
     resolve_runtime_solana_rpc_config,
     resolve_runtime_solana_swap_config,
     resolve_solana_private_key,
+    resolve_wdk_evm_service_url,
     settings,
 )
 from agent_wallet.wallet_layer.base import AgentWalletBackend, WalletBackendError
@@ -20,6 +23,15 @@ from agent_wallet.wallet_layer.solana import SolanaLocalKeypairSigner, SolanaWal
 from agent_wallet.wallet_layer.wdk_btc import WdkBtcLocalWalletBackend
 
 
+def _evm_autostart_disabled() -> bool:
+    return os.getenv("AGENT_WALLET_EVM_DISABLE_AUTOSTART", "").strip().lower() in {
+        "1",
+        "true",
+        "yes",
+        "on",
+    }
+
+
 def _load_keypair_material() -> str | None:
     secret = resolve_solana_private_key()
     if secret:
@@ -91,10 +103,21 @@ def create_wallet_backend() -> AgentWalletBackend | None:
         )
 
     if backend in {"wdk_evm_local", "wdk-evm-local", "evm_local", "evm-local"}:
+        evm_network = normalize_evm_network(settings.solana_network)
+        service_url = resolve_wdk_evm_service_url()
+        if not _evm_autostart_disabled():
+            # Single-agent hosts (Claude Code/Codex) talked to the daemon over
+            # a bare HTTP client with no health check, so an unreachable or
+            # stale daemon surfaced as an opaque connection error instead of
+            # self-healing the way the multi-user OpenClaw path already does.
+            # Reuse that same recovery here instead of duplicating it.
+            from agent_wallet.evm_user_wallets import ensure_local_evm_service_ready
+
+            ensure_local_evm_service_ready(service_url, evm_network)
         return WdkEvmLocalWalletBackend(
-            service_url=settings.wdk_evm_service_url,
+            service_url=service_url,
             wallet_id=settings.wdk_evm_wallet_id,
-            network=settings.solana_network,
+            network=evm_network,
             account_index=settings.wdk_evm_account_index,
             sign_only=settings.agent_wallet_sign_only,
         )

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

package/agent-wallet/scripts/bootstrap_openclaw_evm.py

@@ -10,9 +10,7 @@ import subprocess
 import sys
 import time
 from pathlib import Path
-from urllib.error import URLError
 from urllib.parse import urlparse
-from urllib.request import urlopen
 
 sys.path.insert(0, str(Path(__file__).resolve().parents[1]))
 
@@ -24,6 +22,12 @@ def _default_config_path() -> Path:
     return Path(os.path.expanduser("~/.openclaw/openclaw.json"))
 
 
+def _default_service_url() -> str:
+    from agent_wallet.config import resolve_wdk_evm_service_url
+
+    return resolve_wdk_evm_service_url()
+
+
 def _default_user_id() -> str:
     return f"{os.getenv('USER', 'openclaw-user')}-local"
 
@@ -54,7 +58,7 @@ def build_parser() -> argparse.ArgumentParser:
     parser.add_argument("--plugin-id", default="agent-wallet")
     parser.add_argument("--user-id", default=_default_user_id())
     parser.add_argument("--network", default="base")
-    parser.add_argument("--service-url", default="http://127.0.0.1:8081")
+    parser.add_argument("--service-url", default=_default_service_url())
     parser.add_argument("--wdk-wallet-root", default=str(_repo_root() / "wdk-evm-wallet"))
     parser.add_argument("--label", default="Agent EVM Wallet")
     parser.add_argument("--account-index", type=int, default=0)
@@ -103,15 +107,19 @@ def _health_url(service_url: str) -> str:
 
 
 def _service_is_healthy(service_url: str) -> bool:
-    try:
-        with urlopen(_health_url(service_url), timeout=1.5) as response:
-            return int(getattr(response, "status", 0) or 0) == 200
-    except (URLError, TimeoutError, OSError):
-        return False
+    # Delegate to the shared probe: it dispatches on scheme, so a unix:// URL
+    # (the default since resolve_wdk_evm_service_url moved to a per-home socket)
+    # is fetched over AF_UNIX. urlopen alone raises "unknown url type: unix",
+    # which would make --no-auto-start-service reject a healthy daemon.
+    from agent_wallet.evm_user_wallets import _service_health
+
+    return _service_health(service_url) is not None
 
 
 def _is_local_service_url(service_url: str) -> bool:
     parsed = urlparse(service_url)
+    if parsed.scheme == "unix":
+        return bool(parsed.path)
     return parsed.scheme in {"http", "https"} and parsed.hostname in {"127.0.0.1", "localhost", "::1"}
 
 
@@ -146,7 +154,6 @@ def _auto_start_local_service(
         _service_health,
         _should_restart_local_service,
         _stop_local_service,
-        _write_service_owner,
     )
 
     restarted = False
@@ -167,15 +174,18 @@ def _auto_start_local_service(
         raise SystemExit(f"Could not find wdk-evm-wallet launcher: {run_local}")
 
     parsed = urlparse(service_url)
-    host = parsed.hostname or "127.0.0.1"
-    port = parsed.port or 8081
     log_dir = _service_log_dir(config_path)
     log_dir.mkdir(parents=True, exist_ok=True)
     log_path = _service_log_path(config_path)
 
     env = os.environ.copy()
-    env["HOST"] = host
-    env["PORT"] = str(port)
+    if parsed.scheme == "unix":
+        env["WDK_EVM_TRANSPORT"] = "socket"
+        env["WDK_EVM_SOCKET_PATH"] = parsed.path
+    else:
+        env["WDK_EVM_TRANSPORT"] = "tcp"
+        env["HOST"] = parsed.hostname or "127.0.0.1"
+        env["PORT"] = str(parsed.port or 8081)
     env["WDK_EVM_NETWORK"] = network
     env["WDK_EVM_INSTANCE_ID"] = _expected_local_service_instance_id()
 
@@ -194,7 +204,7 @@ def _auto_start_local_service(
     while time.time() < deadline:
         health = _service_health(service_url)
         if health is not None:
-            pid = _write_service_owner(health, service_url)
+            pid = int(health.get("pid") or 0)
             return {
                 "started": True,
                 "already_healthy": False,

package/agent-wallet/scripts/install_agent_wallet.py

@@ -190,7 +190,7 @@ def build_parser() -> argparse.ArgumentParser:
     parser.add_argument("--extension-path", default=str(_extension_path()))
     parser.add_argument("--wdk-btc-root", default=str(_default_wdk_btc_root()))
     parser.add_argument("--wdk-evm-root", default=str(_default_wdk_evm_root()))
-    parser.add_argument("--wdk-evm-service-url", default=EVM_DEFAULT_SERVICE_URL)
+    parser.add_argument("--wdk-evm-service-url", default=_default_evm_service_url())
     parser.add_argument("--runtime-root", default=str(_default_runtime_root()))
     parser.add_argument("--npm-bin", default=_default_npm_bin())
     parser.add_argument("--plugin-id", default="agent-wallet")
@@ -735,8 +735,8 @@ def _build_next_steps(
     command.extend(["--package-root", str(effective_package_root)])
     command.extend(["--python-bin", str(python_bin)])
     if _is_evm_backend(args.backend):
-        service_url = str(getattr(args, "wdk_evm_service_url", "") or EVM_DEFAULT_SERVICE_URL).strip()
-        command.extend(["--wdk-evm-service-url", service_url or EVM_DEFAULT_SERVICE_URL])
+        service_url = str(getattr(args, "wdk_evm_service_url", "") or _default_evm_service_url()).strip()
+        command.extend(["--wdk-evm-service-url", service_url or _default_evm_service_url()])
     return command
 
 
@@ -753,7 +753,19 @@ def _is_evm_backend(backend: str) -> bool:
     }
 
 
-EVM_DEFAULT_SERVICE_URL = "http://127.0.0.1:8081"
+def _default_evm_service_url() -> str:
+    # This installer bootstraps a brand-new install, so it runs before
+    # agent_wallet's *dependencies* (e.g. pydantic-settings) are guaranteed to
+    # be installed -- putting the package root on sys.path (as other scripts
+    # in this family do) isn't enough, since `import agent_wallet.config`
+    # itself pulls in pydantic_settings. Mirror
+    # agent_wallet.config.resolve_wdk_evm_service_url()'s stdlib-only logic
+    # directly instead of importing it.
+    explicit = os.environ.get("WDK_EVM_SERVICE_URL", "").strip()
+    if explicit:
+        return explicit
+    openclaw_home = Path(os.environ.get("OPENCLAW_HOME", "~/.openclaw")).expanduser()
+    return f"unix://{openclaw_home / 'wdk-evm-wallet' / 'daemon.sock'}"
 
 
 def _build_evm_onboard_config(args: argparse.Namespace) -> dict[str, object]:
@@ -764,12 +776,12 @@ def _build_evm_onboard_config(args: argparse.Namespace) -> dict[str, object]:
     network = args.network.strip().lower() if _is_evm_backend(args.backend) else "base"
     if network not in {"base", "ethereum"}:
         network = "base"
-    service_url = str(getattr(args, "wdk_evm_service_url", "") or EVM_DEFAULT_SERVICE_URL).strip()
+    service_url = str(getattr(args, "wdk_evm_service_url", "") or _default_evm_service_url()).strip()
     return {
         "backend": "wdk_evm_local",
         "network": network,
         "signOnly": bool(args.sign_only),
-        "wdkEvmServiceUrl": service_url or EVM_DEFAULT_SERVICE_URL,
+        "wdkEvmServiceUrl": service_url or _default_evm_service_url(),
     }
 
 

package/agent-wallet/scripts/manage_openclaw_evm_wallet.py

@@ -8,15 +8,17 @@ import json
 import sys
 from getpass import getpass
 from pathlib import Path
-from urllib.error import URLError
-from urllib.request import urlopen
 
 PACKAGE_ROOT = Path(__file__).resolve().parents[1]
 if str(PACKAGE_ROOT) not in sys.path:
     sys.path.insert(0, str(PACKAGE_ROOT))
 
-from agent_wallet.config import normalize_evm_network, settings  # noqa: E402
+from agent_wallet.config import (  # noqa: E402
+    normalize_evm_network,
+    resolve_wdk_evm_service_url,
+)
 from agent_wallet.evm_user_wallets import (  # noqa: E402
+    _service_health as probe_service_health,
     bind_user_evm_wallet,
     create_user_evm_wallet,
     get_user_evm_wallet_binding,
@@ -81,21 +83,22 @@ def _service_health(service_url: str | None) -> dict[str, object]:
     target = str(service_url or "").strip()
     if not target:
         return {"service_url": None, "healthy": False, "error": "service_url is not configured"}
-    health_url = f"{target.rstrip('/')}/health"
-    try:
-        with urlopen(health_url, timeout=1.5) as response:
-            payload = json.loads(response.read().decode("utf-8"))
-            return {
-                "service_url": target,
-                "healthy": int(getattr(response, "status", 0) or 0) == 200,
-                "health": payload,
-            }
-    except (URLError, TimeoutError, OSError, ValueError) as exc:
-        return {"service_url": target, "healthy": False, "error": str(exc)}
+    # Delegate to the shared probe: it dispatches on scheme, so a unix:// URL
+    # (the default since resolve_wdk_evm_service_url moved to a per-home socket)
+    # is fetched over AF_UNIX. urlopen alone raises "unknown url type: unix" and
+    # would report a perfectly healthy socket daemon as down.
+    payload = probe_service_health(target)
+    if payload is None:
+        return {
+            "service_url": target,
+            "healthy": False,
+            "error": f"no healthy /health response from {target}",
+        }
+    return {"service_url": target, "healthy": True, "health": payload}
 
 
 def _status_payload(user_id: str | None, network: str | None, service_url: str | None) -> dict[str, object]:
-    target_service_url = str(service_url or settings.wdk_evm_service_url).strip() or None
+    target_service_url = str(service_url or resolve_wdk_evm_service_url()).strip() or None
     payload: dict[str, object] = {
         "ok": True,
         "network": _normalize_network(network or "ethereum"),

package/agent-wallet/scripts/setup_evm_wallet.sh

@@ -106,7 +106,6 @@ prompt_network_choice() {
 
 DEFAULT_USER_ID=${OPENCLAW_EVM_USER_ID:-${USER:-openclaw-user}-local}
 DEFAULT_NETWORK=${OPENCLAW_EVM_NETWORK:-base}
-DEFAULT_SERVICE_URL=${OPENCLAW_EVM_SERVICE_URL:-http://127.0.0.1:8081}
 
 if ! has_flag --user-id "$@"; then
   USER_ID=$(prompt_with_default "OpenClaw user id" "$DEFAULT_USER_ID")
@@ -118,8 +117,8 @@ if ! has_flag --network "$@"; then
   set -- "$@" --network "$NETWORK"
 fi
 
-if ! has_flag --service-url "$@"; then
-  set -- "$@" --service-url "$DEFAULT_SERVICE_URL"
+if ! has_flag --service-url "$@" && [ -n "${OPENCLAW_EVM_SERVICE_URL:-}" ]; then
+  set -- "$@" --service-url "$OPENCLAW_EVM_SERVICE_URL"
 fi
 
 if ! has_flag --config-path "$@" && [ -n "${OPENCLAW_EVM_CONFIG_PATH:-}" ]; then

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

@@ -1,7 +1,7 @@
 {
   "name": "wallet",
   "displayName": "Agent Wallet",
-  "version": "0.1.103",
+  "version": "0.1.106",
   "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.103",
+  "version": "0.1.106",
   "description": "Codex plugin bridge for the AgentLayer wallet runtime.",
   "author": {
     "name": "AgentLayer"

package/codex/plugins/agent-wallet/server.py

@@ -13,8 +13,10 @@ import selectors
 import signal
 import subprocess
 import sys
+import tempfile
 import threading
 import time
+from contextlib import suppress
 from functools import lru_cache
 from pathlib import Path
 from typing import Any
@@ -122,6 +124,50 @@ def _openclaw_home() -> Path:
     return Path(os.getenv("OPENCLAW_HOME", "~/.openclaw")).expanduser().resolve()
 
 
+def _session_defaults_path() -> Path:
+    return _openclaw_home() / "agent-wallet" / "session-defaults.json"
+
+
+def _read_session_defaults() -> dict[str, Any]:
+    try:
+        payload = json.loads(_session_defaults_path().read_text(encoding="utf-8"))
+    except (FileNotFoundError, json.JSONDecodeError, OSError):
+        return {}
+    return payload if isinstance(payload, dict) else {}
+
+
+def _write_session_default(key: str, value: str) -> None:
+    """Remember a wallet/network switch so the next MCP session starts there.
+
+    set_wallet_backend/set_evm_network previously only mutated this process's
+    module globals ("session_override_active"/"config_file_changed: False" by
+    design) — every new session went back to the static openclaw.json/env
+    default. This is the one persisted side effect: a small, agent-wallet-
+    owned file, separate from the shared openclaw.json so a write here can
+    never clobber unrelated host config. Best-effort — a write failure must
+    never break the tool call that triggered it.
+    """
+    path = _session_defaults_path()
+    try:
+        data = _read_session_defaults()
+        data[key] = value
+        path.parent.mkdir(parents=True, exist_ok=True)
+        fd, temp_path = tempfile.mkstemp(prefix=f".{path.name}.", dir=str(path.parent))
+        try:
+            with os.fdopen(fd, "w", encoding="utf-8") as handle:
+                handle.write(json.dumps(data, indent=2, sort_keys=True) + "\n")
+                handle.flush()
+                os.fsync(handle.fileno())
+            os.chmod(temp_path, 0o600)
+            os.replace(temp_path, path)
+        except Exception:
+            with suppress(FileNotFoundError):
+                os.unlink(temp_path)
+            raise
+    except OSError:
+        pass
+
+
 @lru_cache(maxsize=1)
 def _openclaw_plugin_config() -> dict[str, Any]:
     # Cached for the process lifetime: openclaw.json is read once per MCP server
@@ -469,9 +515,18 @@ def _normalize_btc_network(value: Any) -> str | None:
 
 
 def _default_backend() -> str:
+    # Precedence: explicit env override > last backend the user actually
+    # picked via set_wallet_backend/set_evm_network in some previous session
+    # > the host's static openclaw.json config > the hardcoded fallback.
+    session_default = _read_session_defaults().get("backend")
+    try:
+        normalized_session_default = _normalize_wallet_backend(session_default) if session_default else None
+    except RuntimeError:
+        normalized_session_default = None
     return _normalize_wallet_backend(
         os.getenv("AGENT_WALLET_BACKEND")
         or os.getenv("OPENCLAW_AGENT_WALLET_BACKEND")
+        or normalized_session_default
         or _configured_backend()
         or "solana_local"
     )
@@ -481,6 +536,12 @@ def _default_evm_network() -> str | None:
     configured = _normalize_evm_network(os.getenv("WDK_EVM_NETWORK"))
     if configured in {"ethereum", "base", "robinhood", "goat"}:
         return configured
+    session_default = _read_session_defaults().get("evm_network")
+    if session_default:
+        try:
+            return _normalize_selectable_evm_network(session_default)
+        except RuntimeError:
+            pass
     return _configured_network_for_backend("wdk_evm_local")
 
 
@@ -1381,6 +1442,9 @@ async def _handle_set_wallet_backend(params: dict[str, Any]) -> dict[str, Any]:
     else:
         selected_solana_network = resolved_network
     selected_wallet_backend = backend
+    _write_session_default("backend", backend)
+    if backend == "wdk_evm_local":
+        _write_session_default("evm_network", resolved_network)
     return {
         "selected_backend": backend,
         "selected_wallet": _backend_label(backend),
@@ -1388,9 +1452,11 @@ async def _handle_set_wallet_backend(params: dict[str, Any]) -> dict[str, Any]:
         "configured_backend": _default_backend(),
         "session_override_active": True,
         "config_file_changed": False,
+        "remembered_as_default": True,
         "usage": (
-            "Subsequent wallet calls in this Codex MCP session use this wallet backend by "
-            "default. The runtime startup config remains unchanged."
+            "Wallet calls in this session use this backend by default, and the next MCP "
+            "session starts here too. openclaw.json/env config is unchanged; use those for "
+            "a fixed deployment-wide default instead."
         ),
         "data": payload.get("data", {}),
     }
@@ -1407,15 +1473,19 @@ async def _handle_set_evm_network(params: dict[str, Any]) -> dict[str, Any]:
         raise RuntimeError(str(payload.get("error") or "set_evm_network failed"))
     selected_wallet_backend = "wdk_evm_local"
     selected_evm_network = network
+    _write_session_default("backend", "wdk_evm_local")
+    _write_session_default("evm_network", network)
     return {
         "selected_backend": "wdk_evm_local",
         "selected_wallet": "evm",
         "selected_network": network,
         "session_active_network": network,
         "session_override_active": True,
+        "remembered_as_default": True,
         "usage": (
-            "Subsequent EVM wallet calls in this Codex MCP session use this network by default. "
-            "You can still override a single EVM call with its network parameter."
+            "EVM wallet calls in this session use this network by default, and the next MCP "
+            "session starts here too. You can still override a single call with its network "
+            "parameter."
         ),
         "data": payload.get("data", {}),
     }

package/hermes/plugins/agent_wallet/plugin.yaml

@@ -1,5 +1,5 @@
 name: agent-wallet
-version: 0.1.103
+version: 0.1.106
 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.103",
+  "version": "0.1.106",
   "description": "Universal AgentLayer wallet installer for OpenClaw, Codex, Claude Code, and Hermes.",
   "type": "module",
   "repository": {

package/wdk-btc-wallet/package.json

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

package/wdk-evm-wallet/README.md

@@ -181,8 +181,12 @@ cd wdk-evm-wallet && sh run-local.sh
 
 Environment variables:
 
-- `HOST`
-- `PORT`
+- `WDK_EVM_TRANSPORT` — `socket` (default) or `tcp`. `socket` serves over a unix
+  domain socket at `WDK_EVM_SOCKET_PATH`; `tcp` serves over `HOST`/`PORT`.
+- `WDK_EVM_SOCKET_PATH` — unix socket path, used only when `WDK_EVM_TRANSPORT=socket`.
+  Defaults to `<dataDir>/daemon.sock`.
+- `HOST` — used only when `WDK_EVM_TRANSPORT=tcp`.
+- `PORT` — used only when `WDK_EVM_TRANSPORT=tcp`.
 - `WDK_EVM_NETWORK`
 - `WDK_EVM_DATA_DIR`
 - `WDK_EVM_LOCAL_TOKEN`

package/wdk-evm-wallet/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wdk-evm-wallet",
-  "version": "0.1.103",
+  "version": "0.1.106",
   "private": true,
   "type": "module",
   "description": "Separate EVM wallet service built on Tether WDK.",
@@ -19,7 +19,8 @@
     "test:shutdown": "node --test tests/shutdown.test.mjs",
     "test:network-config": "node --test tests/unit_network_config.mjs",
     "test:network-state": "node --test tests/unit_network_state.mjs",
-    "test:wallet-network": "node --test tests/unit_wdk_wallet_network.mjs"
+    "test:wallet-network": "node --test tests/unit_wdk_wallet_network.mjs",
+    "test:socket-transport": "node --test tests/unit_socket_transport.mjs"
   },
   "dependencies": {
     "@morpho-org/morpho-sdk": "^3.2.0",