@agentlayer.tech/wallet 0.1.103 → 0.1.106

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

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

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

package/VERSION

@@ -1 +1 @@
-0.1.103
+0.1.106

package/agent-wallet/README.md

@@ -403,14 +403,19 @@ sh agent-wallet/scripts/setup_evm_wallet.sh
 That wrapper:
 
 - prompts for `user-id` and EVM network when run interactively
-- defaults to `http://127.0.0.1:8081`
+- defaults to a per-install unix socket at `~/.openclaw/wdk-evm-wallet/daemon.sock`
+  (or wherever `OPENCLAW_HOME` points); set `WDK_EVM_SERVICE_URL` to override
+  with an explicit `unix://` or `http://` URL for either transport
 - can auto-start `wdk-evm-wallet/run-local.sh` if the local service is not already healthy
 - creates or unlocks the local EVM wallet binding
 - also binds the paired EVM network by default: `ethereum <-> base` (GOAT remains an independent EVM network binding)
 - stores the entered EVM vault password into `sealed_keys.json` when `AGENT_WALLET_BOOT_KEY` is available, so later OpenClaw wallet switching can auto-raise the EVM backend without another password prompt
 - patches OpenClaw config to `backend=wdk_evm_local`
 
-Example host-side EVM wallet creation:
+Example host-side EVM wallet creation (explicit TCP `wdkEvmServiceUrl` override —
+TCP mode is an opt-in for advanced/remote deployments via `WDK_EVM_TRANSPORT=tcp`
+on the `wdk-evm-wallet` side, and no longer gets the same protection against a
+foreign daemon sharing the port that the unix-socket default gets by construction):
 
 ```bash
 printf '%s\n' 'your-local-evm-password' | \

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

package/agent-wallet/agent_wallet/config.py

@@ -44,7 +44,7 @@ class Settings(BaseSettings):
     wdk_btc_service_url: str = "http://127.0.0.1:8080"
     wdk_btc_wallet_id: str = ""
     wdk_btc_account_index: int = 0
-    wdk_evm_service_url: str = "http://127.0.0.1:8081"
+    wdk_evm_service_url: str = ""
     wdk_evm_wallet_id: str = ""
     wdk_evm_account_index: int = 0
 
@@ -200,6 +200,20 @@ def resolve_openclaw_home() -> Path:
     return Path(raw).expanduser()
 
 
+def resolve_wdk_evm_service_url() -> str:
+    """Resolve the wdk-evm-wallet service URL, unix-socket by default.
+
+    An explicit WDK_EVM_SERVICE_URL/settings value always wins, whatever
+    transport it names (http:// for an explicit TCP deployment, unix:// for
+    a non-default socket path). Otherwise this is a per-OPENCLAW_HOME unix
+    socket — see docs/superpowers/specs/2026-08-30-evm-wallet-unix-socket-transport-design.md.
+    """
+    explicit = settings.wdk_evm_service_url.strip()
+    if explicit:
+        return explicit
+    return f"unix://{resolve_openclaw_home() / 'wdk-evm-wallet' / 'daemon.sock'}"
+
+
 def default_solana_wallet_path(network: str) -> Path:
     """Return the default keypair path for a Solana wallet."""
     normalized_network = normalize_solana_network(network)

package/agent-wallet/agent_wallet/evm_user_wallets.py

@@ -2,11 +2,12 @@
 
 from __future__ import annotations
 
+import http.client
 import json
 import os
 import secrets
-import shutil
 import signal
+import socket as socket_module
 import subprocess
 import time
 from pathlib import Path
@@ -20,6 +21,7 @@ from agent_wallet.config import (
     resolve_boot_key,
     resolve_evm_wallet_password,
     resolve_openclaw_home,
+    resolve_wdk_evm_service_url,
     settings,
 )
 from agent_wallet.file_ops import atomic_write_text
@@ -28,7 +30,6 @@ from agent_wallet.user_wallets import normalize_user_id
 from agent_wallet.wallet_layer.base import WalletBackendError
 
 LOCAL_WDK_EVM_HOSTS = {"127.0.0.1", "localhost", "::1"}
-_SERVICE_OWNER_FILENAME = "service-owner.json"
 _INSTANCE_ID_FILENAME = "instance-id"
 
 
@@ -37,7 +38,7 @@ def _normalize_evm_network(value: str | None) -> str:
 
 
 def _resolve_service_url(service_url: str | None = None) -> str:
-    effective = (service_url or settings.wdk_evm_service_url).strip()
+    effective = (service_url or resolve_wdk_evm_service_url()).strip()
     if not effective:
         raise WalletBackendError("wdk_evm_service_url is required for EVM wallet host operations.")
     return effective
@@ -51,7 +52,22 @@ def _paired_network(network: str) -> str | None:
     return mapping.get(_normalize_evm_network(network))
 
 
+class _UnixHealthConnection(http.client.HTTPConnection):
+    """Minimal HTTPConnection over AF_UNIX, for the unauthenticated /health probe."""
+
+    def __init__(self, socket_path: str, timeout: float = 1.5):
+        super().__init__("localhost", timeout=timeout)
+        self._socket_path = socket_path
+
+    def connect(self) -> None:
+        self.sock = socket_module.socket(socket_module.AF_UNIX, socket_module.SOCK_STREAM)
+        self.sock.settimeout(self.timeout)
+        self.sock.connect(self._socket_path)
+
+
 def _health_url(service_url: str) -> str:
+    # Display/error-message use only now — unix:// targets are fetched via
+    # _UnixHealthConnection below, not urlopen, which has no unix-socket support.
     return f"{service_url.rstrip('/')}/health"
 
 
@@ -61,12 +77,24 @@ def _service_health(service_url: str) -> dict[str, Any] | None:
     An empty dict means the service answered 200 but the body was unparseable —
     treated as "running, version unknown" so we never restart on a parse blip.
     """
+    parsed = urlparse(service_url)
     try:
-        with urlopen(_health_url(service_url), timeout=1.5) as response:
-            if int(getattr(response, "status", 0) or 0) != 200:
-                return None
-            raw = response.read()
-    except (URLError, TimeoutError, OSError):
+        if parsed.scheme == "unix":
+            conn = _UnixHealthConnection(parsed.path, timeout=1.5)
+            try:
+                conn.request("GET", "/health")
+                response = conn.getresponse()
+                if response.status != 200:
+                    return None
+                raw = response.read()
+            finally:
+                conn.close()
+        else:
+            with urlopen(_health_url(service_url), timeout=1.5) as response:
+                if int(getattr(response, "status", 0) or 0) != 200:
+                    return None
+                raw = response.read()
+    except (URLError, TimeoutError, OSError, http.client.HTTPException):
         return None
     try:
         payload = json.loads(raw.decode("utf-8"))
@@ -109,50 +137,6 @@ def _expected_local_service_instance_id() -> str:
     return generated
 
 
-def _service_owner_path() -> Path:
-    return _expected_local_service_data_dir() / _SERVICE_OWNER_FILENAME
-
-
-def _read_service_owner() -> dict[str, Any] | None:
-    try:
-        payload = json.loads(_service_owner_path().read_text(encoding="utf-8"))
-    except (OSError, ValueError):
-        return None
-    return payload if isinstance(payload, dict) else None
-
-
-def _write_service_owner(health: dict[str, Any], service_url: str) -> int:
-    expected_instance = _expected_local_service_instance_id()
-    instance_id = str(health.get("instanceId") or "").strip()
-    try:
-        pid = int(health.get("pid") or 0)
-    except (TypeError, ValueError):
-        pid = 0
-    if instance_id != expected_instance or pid <= 0:
-        raise WalletBackendError("wdk-evm-wallet health did not confirm local process ownership.")
-    payload = {
-        "version": 1,
-        "pid": pid,
-        "instance_id": instance_id,
-        "port": urlparse(service_url).port or 8081,
-        "data_dir": str(_expected_local_service_data_dir()),
-        "service_version": str(health.get("version") or "").strip() or None,
-    }
-    atomic_write_text(_service_owner_path(), json.dumps(payload, indent=2) + "\n", mode=0o600)
-    return pid
-
-
-def _same_path(left: str | Path | None, right: str | Path | None) -> bool:
-    if left is None or right is None:
-        return False
-    try:
-        left_path = Path(str(left)).expanduser().resolve()
-        right_path = Path(str(right)).expanduser().resolve()
-    except OSError:
-        return False
-    return left_path == right_path
-
-
 def _should_restart_local_service(
     health: dict[str, Any] | None,
     *,
@@ -162,42 +146,7 @@ def _should_restart_local_service(
         return False
     expected_version = _read_on_disk_service_version(wallet_root) if wallet_root is not None else None
     running_version = str(health.get("version") or "").strip()
-    if expected_version and running_version and running_version != expected_version:
-        return True
-
-    reported_data_dir = str(health.get("dataDir") or "").strip()
-    if reported_data_dir and not _same_path(reported_data_dir, _expected_local_service_data_dir()):
-        return True
-
-    reported_instance = str(health.get("instanceId") or "").strip()
-    if reported_data_dir and reported_instance != _expected_local_service_instance_id():
-        return True
-
-    return False
-
-
-def _listening_pids(port: int) -> list[int]:
-    """PIDs LISTENing on a local TCP port (via lsof), excluding our own."""
-    lsof = shutil.which("lsof")
-    if not lsof:
-        return []
-    try:
-        completed = subprocess.run(  # noqa: S603
-            [lsof, "-t", "-i", f"tcp:{port}", "-sTCP:LISTEN"],
-            capture_output=True,
-            text=True,
-            timeout=5,
-        )
-    except (OSError, subprocess.SubprocessError):
-        return []
-    pids: list[int] = []
-    for token in completed.stdout.split():
-        token = token.strip()
-        if token.isdigit():
-            pid = int(token)
-            if pid != os.getpid():
-                pids.append(pid)
-    return pids
+    return bool(expected_version and running_version and running_version != expected_version)
 
 
 def _daemon_takeover_disabled() -> bool:
@@ -209,40 +158,13 @@ def _daemon_takeover_disabled() -> bool:
     }
 
 
-def _takeover_refusal(port: int, listeners: list[int], data_dir: str, reason: str) -> str:
-    pids = ", ".join(str(pid) for pid in listeners) if listeners else "unknown"
+def _takeover_refusal(reason: str) -> str:
     return (
-        f"Refusing to stop the wdk-evm-wallet on port {port}: {reason}. "
-        f"Listening PIDs: {pids}. Daemon dataDir: {data_dir or 'unknown'}. "
-        f"To clear it manually: lsof -nP -iTCP:{port} -sTCP:LISTEN, then kill <pid>."
+        f"Refusing to stop wdk-evm-wallet: {reason}. "
+        "To clear it manually: check /health at the configured service URL for its pid, then kill <pid>."
     )
 
 
-def _process_cwd(pid: int) -> Path | None:
-    """Return a process working directory via lsof, or None when unverified."""
-    lsof = shutil.which("lsof")
-    if not lsof:
-        return None
-    try:
-        completed = subprocess.run(  # noqa: S603
-            [lsof, "-a", "-p", str(pid), "-d", "cwd", "-Fn"],
-            capture_output=True,
-            text=True,
-            timeout=5,
-        )
-    except (OSError, subprocess.SubprocessError):
-        return None
-    if completed.returncode != 0:
-        return None
-    for line in completed.stdout.splitlines():
-        if line.startswith("n") and line[1:].strip():
-            try:
-                return Path(line[1:].strip()).resolve()
-            except OSError:
-                return None
-    return None
-
-
 def _process_exists(pid: int) -> bool:
     try:
         os.kill(pid, 0)
@@ -253,129 +175,52 @@ def _process_exists(pid: int) -> bool:
         return True
 
 
-def _process_released_service(pid: int, port: int, service_url: str) -> bool:
+def _process_released_service(pid: int, service_url: str) -> bool:
     if not _process_exists(pid):
         return True
-    # A daemon signalled by a process other than its parent can remain briefly
-    # as a zombie. Once its listener and health endpoint are both gone, it no
-    # longer blocks the updated runtime and is considered released.
-    return pid not in _listening_pids(port) and _service_health(service_url) is None
-
-
-def _owner_matches(
-    owner: dict[str, Any] | None,
-    current_health: dict[str, Any],
-    *,
-    pid: int,
-    port: int,
-) -> bool:
-    if owner is None:
-        return not _service_owner_path().exists()
-    try:
-        owner_pid = int(owner.get("pid") or 0)
-        owner_port = int(owner.get("port") or 0)
-    except (TypeError, ValueError):
-        return False
-    return (
-        owner_pid == pid
-        and owner_port == port
-        and _same_path(owner.get("data_dir"), _expected_local_service_data_dir())
-        and str(owner.get("instance_id") or "")
-        == str(current_health.get("instanceId") or "")
-    )
+    # A daemon signalled by a process other than its parent can remain
+    # briefly as a zombie. Once its health endpoint is gone it no longer
+    # blocks a fresh daemon from claiming the socket.
+    return _service_health(service_url) is None
 
 
-def _resolve_stoppable_pid(current_health: dict[str, Any], port: int) -> int:
-    """Return a strictly verified same-home daemon PID, or 0 to fail closed."""
-    reported_data_dir = str(current_health.get("dataDir") or "").strip()
-    if not _same_path(reported_data_dir, _expected_local_service_data_dir()):
-        return 0
-    listeners = _listening_pids(port)
-    if not listeners:
-        return 0
+def _resolve_stoppable_pid(current_health: dict[str, Any]) -> int:
+    """Return the daemon's reported PID, or 0 if it didn't report one."""
     try:
-        reported_pid = int(current_health.get("pid") or 0)
+        pid = int(current_health.get("pid") or 0)
     except (TypeError, ValueError):
-        reported_pid = 0
-    if reported_pid > 0:
-        if reported_pid not in listeners:
-            return 0
-        candidate = reported_pid
-    elif len(listeners) == 1:
-        # One-time compatibility for a pre-PID daemon. The listener and its
-        # working directory still have to identify the bundled service.
-        candidate = listeners[0]
-    else:
-        return 0
-    cwd = _process_cwd(candidate)
-    if cwd is None or cwd.name != "wdk-evm-wallet":
-        return 0
-    if not _owner_matches(_read_service_owner(), current_health, pid=candidate, port=port):
         return 0
-    return candidate
+    return pid if pid > 0 else 0
 
 
 def _stop_local_service(service_url: str, health: dict[str, Any] | None = None) -> None:
     """Gracefully stop a local wdk-evm-wallet daemon so a fresh one can start.
 
-    SIGTERM the listener(s), wait for /health to drop, then SIGKILL as a fallback.
+    SIGTERM the listener, wait for /health to drop, then SIGKILL as a fallback.
     """
     port = urlparse(service_url).port or 8081
     current_health = health if health is not None else _service_health(service_url)
     if not current_health or current_health.get("service") != "wdk-evm-wallet":
-        raise WalletBackendError(
-            f"Refusing to stop an unidentified service on port {port}."
-        )
-    listeners = _listening_pids(port)
-    reported_data_dir = str(current_health.get("dataDir") or "").strip()
+        raise WalletBackendError(f"Refusing to stop an unidentified service on port {port}.")
 
     if _daemon_takeover_disabled():
         raise WalletBackendError(
-            _takeover_refusal(
-                port,
-                listeners,
-                reported_data_dir,
-                "takeover is disabled by OPENCLAW_EVM_DISABLE_DAEMON_TAKEOVER",
-            )
+            _takeover_refusal("takeover is disabled by OPENCLAW_EVM_DISABLE_DAEMON_TAKEOVER")
         )
 
-    if not _same_path(reported_data_dir, _expected_local_service_data_dir()):
-        raise WalletBackendError(
-            _takeover_refusal(
-                port,
-                listeners,
-                reported_data_dir,
-                "the daemon belongs to a different wallet home",
-            )
-        )
-
-    owned_pid = _resolve_stoppable_pid(current_health, port)
+    owned_pid = _resolve_stoppable_pid(current_health)
     if owned_pid <= 0:
         raise WalletBackendError(
-            _takeover_refusal(
-                port,
-                listeners,
-                reported_data_dir,
-                "the listening process could not be identified",
-            )
+            _takeover_refusal("the daemon's /health response did not include a pid")
         )
 
     try:
         os.kill(owned_pid, 0)
     except ProcessLookupError:
-        try:
-            _service_owner_path().unlink()
-        except FileNotFoundError:
-            pass
         return
     except PermissionError as exc:
         raise WalletBackendError(
-            _takeover_refusal(
-                port,
-                listeners,
-                reported_data_dir,
-                f"pid {owned_pid} belongs to another user ({exc})",
-            )
+            _takeover_refusal(f"pid {owned_pid} belongs to another user ({exc})")
         ) from exc
 
     try:
@@ -383,45 +228,31 @@ def _stop_local_service(service_url: str, health: dict[str, Any] | None = None)
     except ProcessLookupError:
         pass
     except PermissionError as exc:
-        raise WalletBackendError(
-            f"Cannot stop stale wdk-evm-wallet (pid {owned_pid}): {exc}."
-        ) from exc
+        raise WalletBackendError(f"Cannot stop stale wdk-evm-wallet (pid {owned_pid}): {exc}.") from exc
+
     deadline = time.time() + 10.0
     while time.time() < deadline:
-        if _process_released_service(owned_pid, port, service_url):
-            try:
-                _service_owner_path().unlink()
-            except FileNotFoundError:
-                pass
+        if _process_released_service(owned_pid, service_url):
             return
         time.sleep(0.3)
-    # Re-run the socket/cwd/owner checks immediately before a hard stop. A PID
-    # that exited and was reused must never inherit permission from old health.
+
+    # Re-check immediately before a hard stop. A PID that exited and was
+    # reused must never inherit permission from stale health.
     refreshed_health = _service_health(service_url)
     if (
         not refreshed_health
         or refreshed_health.get("service") != "wdk-evm-wallet"
-        or _resolve_stoppable_pid(refreshed_health, port) != owned_pid
+        or _resolve_stoppable_pid(refreshed_health) != owned_pid
     ):
-        raise WalletBackendError(
-            _takeover_refusal(
-                port,
-                _listening_pids(port),
-                str((refreshed_health or {}).get("dataDir") or ""),
-                "process identity changed before the hard stop",
-            )
-        )
+        raise WalletBackendError(_takeover_refusal("process identity changed before the hard stop"))
+
     try:
         os.kill(owned_pid, signal.SIGKILL)
     except ProcessLookupError:
         pass
     deadline = time.time() + 5.0
     while time.time() < deadline:
-        if _process_released_service(owned_pid, port, service_url):
-            try:
-                _service_owner_path().unlink()
-            except FileNotFoundError:
-                pass
+        if _process_released_service(owned_pid, service_url):
             return
         time.sleep(0.3)
     raise WalletBackendError(f"Failed to stop stale wdk-evm-wallet on port {port}.")
@@ -429,6 +260,11 @@ def _stop_local_service(service_url: str, health: dict[str, Any] | None = None)
 
 def _is_local_service_url(service_url: str) -> bool:
     parsed = urlparse(service_url)
+    if parsed.scheme == "unix":
+        # A unix socket is local by construction. Mirrors the same acceptance in
+        # scripts/bootstrap_openclaw_evm.py and providers/wdk_evm_local.py; without
+        # it _auto_start_local_service refuses the default service URL outright.
+        return bool(parsed.path)
     return parsed.scheme in {"http", "https"} and parsed.hostname in LOCAL_WDK_EVM_HOSTS
 
 
@@ -453,16 +289,14 @@ def _auto_start_local_service(service_url: str, network: str) -> None:
     health = _service_health(service_url)
     if health is not None:
         # Already running. The daemon loads code once at boot (no hot-reload), so a
-        # long-running process keeps serving stale code after a release. It can also
-        # keep serving the wrong local vault after a temp/smoke install left another
-        # daemon on the shared localhost port. Restart only when the local daemon no
-        # longer matches the expected launcher version or expected dataDir. Remote
-        # (non-local) healthy services we don't manage are left untouched.
+        # long-running process keeps serving stale code after a release. Restart
+        # only when the local daemon no longer matches the expected launcher
+        # version — its socket path is scoped to this dataDir, so nothing foreign
+        # can answer here. Remote (non-local) healthy services we don't manage are
+        # left untouched.
         if not _is_local_service_url(service_url):
             return
         if not _should_restart_local_service(health, wallet_root=wallet_root):
-            if str(health.get("instanceId") or "").strip():
-                _write_service_owner(health, service_url)
             return
         _stop_local_service(service_url, health)
     if not _is_local_service_url(service_url):
@@ -475,8 +309,13 @@ def _auto_start_local_service(service_url: str, network: str) -> None:
         )
     parsed = urlparse(service_url)
     env = os.environ.copy()
-    env["HOST"] = parsed.hostname or "127.0.0.1"
-    env["PORT"] = str(parsed.port or 8081)
+    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"] = _normalize_evm_network(network)
     env["WDK_EVM_INSTANCE_ID"] = _expected_local_service_instance_id()
     process = subprocess.Popen(  # noqa: S603
@@ -492,7 +331,6 @@ def _auto_start_local_service(service_url: str, network: str) -> None:
     while time.time() < deadline:
         health = _service_health(service_url)
         if health is not None:
-            _write_service_owner(health, service_url)
             return
         if process.poll() is not None:
             raise WalletBackendError("wdk-evm-wallet exited before becoming healthy.")
@@ -502,6 +340,25 @@ def _auto_start_local_service(service_url: str, network: str) -> None:
     )
 
 
+def ensure_local_evm_service_ready(service_url: str, network: str) -> None:
+    """Public entry point for callers outside the OpenClaw user-wallet flow.
+
+    Thin wrapper around `_auto_start_local_service`, which was previously only
+    reachable through `ensure_user_evm_wallet_ready`/`resolve_user_evm_wallet_binding`
+    (the multi-user OpenClaw gateway/Hermes path). The single-agent factory
+    (`wallet_layer.factory.create_wallet_backend`) has no user_id and doesn't
+    need one — the underlying ownership/health checks are already keyed off
+    `service_url`/`OPENCLAW_HOME`, not the caller's user. Exposing this lets
+    both paths share one recovery implementation instead of drifting apart.
+
+    Raises `WalletBackendError` for anything the auto-start/eviction logic
+    can't resolve on its own (e.g. a foreign-home daemon occupying the port);
+    callers should let that surface as a clear tool error rather than a raw
+    connection failure.
+    """
+    _auto_start_local_service(service_url, network)
+
+
 def _resolve_user_evm_wallet_dir(user_id: str) -> Path:
     return resolve_openclaw_home() / "users" / normalize_user_id(user_id) / "wallets"
 

package/agent-wallet/agent_wallet/openclaw_runtime.py

@@ -8,7 +8,12 @@ from typing import Any
 from agent_wallet.approval import issue_approval_token
 from agent_wallet.boot_key_migration import migrate_boot_key_to_keystore
 from agent_wallet.btc_user_wallets import get_user_btc_wallet_binding
-from agent_wallet.config import normalize_btc_network, normalize_evm_network, settings
+from agent_wallet.config import (
+    normalize_btc_network,
+    normalize_evm_network,
+    resolve_wdk_evm_service_url,
+    settings,
+)
 from agent_wallet.evm_user_wallets import ensure_user_evm_wallet_ready
 from agent_wallet.models import OpenClawWalletSessionMetadata
 from agent_wallet.openclaw_adapter import OpenClawWalletAdapter
@@ -181,7 +186,7 @@ def onboard_openclaw_user_wallet(
         )
 
     if backend_name in {"wdk_evm_local", "wdk-evm-local", "evm_local", "evm-local"}:
-        service_url = str(wdk_evm_service_url or settings.wdk_evm_service_url).strip()
+        service_url = str(wdk_evm_service_url or resolve_wdk_evm_service_url()).strip()
         account_index = (
             settings.wdk_evm_account_index
             if wdk_evm_account_index is None