@agentlayer.tech/wallet 0.1.73 → 0.1.75

package/agent-wallet/agent_wallet/evm_user_wallets.py

@@ -22,11 +22,14 @@ from agent_wallet.config import (
     resolve_openclaw_home,
     settings,
 )
+from agent_wallet.file_ops import atomic_write_text
 from agent_wallet.providers.wdk_evm_local import WdkEvmLocalClient
 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"
 
 
 def _normalize_evm_network(value: str | None) -> str:
@@ -93,6 +96,52 @@ def _expected_local_service_data_dir() -> Path:
     return (resolve_openclaw_home() / "wdk-evm-wallet").resolve()
 
 
+def _expected_local_service_instance_id() -> str:
+    path = _expected_local_service_data_dir() / _INSTANCE_ID_FILENAME
+    try:
+        existing = path.read_text(encoding="utf-8").strip()
+    except OSError:
+        existing = ""
+    if existing:
+        return existing
+    generated = secrets.token_hex(16)
+    atomic_write_text(path, generated + "\n", mode=0o600)
+    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
@@ -120,6 +169,10 @@ def _should_restart_local_service(
     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
 
 
@@ -147,42 +200,77 @@ def _listening_pids(port: int) -> list[int]:
     return pids
 
 
-def _stop_local_service(service_url: str) -> None:
+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.
     """
     port = urlparse(service_url).port or 8081
-    pids = _listening_pids(port)
-    if not pids:
-        # Nothing identifiable to stop (e.g. lsof missing). Surface a clear,
-        # actionable error rather than racing into an EADDRINUSE start failure.
+    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"A stale wdk-evm-wallet is running on port {port} but could not be "
-            "identified to restart it. Stop it manually and retry."
+            f"Refusing to stop an unidentified service on port {port}."
         )
-    for pid in pids:
-        try:
-            os.kill(pid, signal.SIGTERM)
-        except ProcessLookupError:
-            continue
-        except PermissionError as exc:
-            raise WalletBackendError(
-                f"Cannot stop stale wdk-evm-wallet (pid {pid}): {exc}."
-            ) from exc
+    listeners = _listening_pids(port)
+    owner = _read_service_owner()
+    expected_instance = _expected_local_service_instance_id()
+    reported_instance = str(current_health.get("instanceId") or "").strip()
+    reported_data_dir = str(current_health.get("dataDir") or "").strip()
+    try:
+        reported_pid = int(current_health.get("pid") or 0)
+    except (TypeError, ValueError):
+        reported_pid = 0
+
+    owned_pid = 0
+    if reported_instance == expected_instance and reported_pid > 0:
+        owner_matches = (
+            not owner
+            or (
+                int(owner.get("pid") or 0) == reported_pid
+                and str(owner.get("instance_id") or "") == expected_instance
+                and int(owner.get("port") or 0) == port
+            )
+            or int(owner.get("pid") or 0) not in listeners
+        )
+        if owner_matches and (not listeners or reported_pid in listeners):
+            owned_pid = reported_pid
+    elif not reported_instance and reported_data_dir and len(listeners) == 1:
+        # One-time compatibility path for pre-instance-id daemons.
+        owned_pid = listeners[0]
+
+    if owned_pid <= 0:
+        raise WalletBackendError(
+            f"A stale wdk-evm-wallet is running on port {port} but ownership could not be verified. "
+            "Stop it manually and retry."
+        )
+    try:
+        os.kill(owned_pid, signal.SIGTERM)
+    except ProcessLookupError:
+        pass
+    except PermissionError as 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 _service_health(service_url) is None:
+            try:
+                _service_owner_path().unlink()
+            except FileNotFoundError:
+                pass
             return
         time.sleep(0.3)
-    for pid in _listening_pids(port):
-        try:
-            os.kill(pid, signal.SIGKILL)
-        except ProcessLookupError:
-            continue
+    try:
+        os.kill(owned_pid, signal.SIGKILL)
+    except ProcessLookupError:
+        pass
     deadline = time.time() + 5.0
     while time.time() < deadline:
         if _service_health(service_url) is None:
+            try:
+                _service_owner_path().unlink()
+            except FileNotFoundError:
+                pass
             return
         time.sleep(0.3)
     raise WalletBackendError(f"Failed to stop stale wdk-evm-wallet on port {port}.")
@@ -222,8 +310,10 @@ def _auto_start_local_service(service_url: str, network: str) -> None:
         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)
+        _stop_local_service(service_url, health)
     if not _is_local_service_url(service_url):
         raise WalletBackendError(
             f"wdk-evm-wallet is unreachable at {_health_url(service_url)} and auto-start only supports localhost URLs."
@@ -237,6 +327,7 @@ def _auto_start_local_service(service_url: str, network: str) -> None:
     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
         ["sh", str(wallet_root / "run-local.sh")],
         cwd=str(wallet_root),
@@ -248,7 +339,9 @@ def _auto_start_local_service(service_url: str, network: str) -> None:
     )
     deadline = time.time() + 30.0
     while time.time() < deadline:
-        if _service_is_healthy(service_url):
+        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.")

package/agent-wallet/agent_wallet/keystore.py

@@ -13,6 +13,7 @@ BOOT_KEY_KEYCHAIN_ARCHITECTURE.md.
 
 from __future__ import annotations
 
+import json
 import os
 import platform
 import shutil
@@ -27,6 +28,8 @@ KEYSTORE_SERVICE = "ai.agentlayer.wallet"
 BOOT_KEY_ITEM = "boot_key"
 _PROBE_ITEM = "__probe__"
 _KEYSTORE_BACKEND_ENV = "AGENT_WALLET_KEYSTORE_BACKEND"
+_KEYSTORE_STATE_VERSION = 1
+_KEYSTORE_STATE_FILENAME = "backend.json"
 
 _SECURITY_BIN = "/usr/bin/security"
 _SUBPROCESS_TIMEOUT = 10.0
@@ -49,6 +52,31 @@ def _backend_preference() -> str:
     return os.getenv(_KEYSTORE_BACKEND_ENV, "auto").strip().lower()
 
 
+def _state_path() -> Path:
+    return resolve_openclaw_home() / "keystore" / _KEYSTORE_STATE_FILENAME
+
+
+def _read_backend_state() -> dict[str, str] | None:
+    try:
+        payload = json.loads(_state_path().read_text(encoding="utf-8"))
+    except (OSError, ValueError):
+        return None
+    if not isinstance(payload, dict) or payload.get("version") != _KEYSTORE_STATE_VERSION:
+        return None
+    backend = str(payload.get("backend") or "").strip()
+    service = str(payload.get("service") or "").strip()
+    if backend not in {
+        "macos-keychain",
+        "windows-dpapi",
+        "linux-secretservice",
+        "plaintext-file",
+    }:
+        return None
+    if service != _service():
+        return None
+    return {"backend": backend, "service": service}
+
+
 class KeyStoreError(Exception):
     """Raised when a keystore backend operation fails unexpectedly."""
 
@@ -247,7 +275,7 @@ class PlaintextFileStore:
             pass
 
 
-_keystore_cache: dict[tuple[str, str], KeyStore] = {}
+_keystore_cache: dict[tuple[str, str, str], KeyStore] = {}
 
 
 def clear_keystore_cache() -> None:
@@ -263,7 +291,11 @@ def resolve_keystore() -> KeyStore:
     (preference, service) for the process lifetime. Cleared by
     ``agent_wallet.config.clear_secret_caches`` / ``reload_settings``.
     """
-    cache_key = (_backend_preference(), _service())
+    cache_key = (
+        _backend_preference(),
+        _service(),
+        str(resolve_openclaw_home().resolve()),
+    )
     cached = _keystore_cache.get(cache_key)
     if cached is not None:
         return cached
@@ -293,6 +325,12 @@ def _resolve_keystore_uncached() -> KeyStore:
         # _backend_usable falls back gracefully if a session still can't authorize.
         candidates = [MacKeychainStore(), WindowsDpapiStore(), LinuxSecretServiceStore()]
 
+    if preference == "auto":
+        state = _read_backend_state()
+        pinned = _store_for_backend(state["backend"]) if state else None
+        if pinned is not None:
+            candidates = [pinned, *[item for item in candidates if item.backend_id != pinned.backend_id]]
+
     for candidate in candidates:
         try:
             if candidate.available() and _backend_usable(candidate):
@@ -302,6 +340,48 @@ def _resolve_keystore_uncached() -> KeyStore:
     return PlaintextFileStore()
 
 
+def _store_for_backend(backend_id: str) -> KeyStore | None:
+    stores: dict[str, KeyStore] = {
+        "macos-keychain": MacKeychainStore(),
+        "windows-dpapi": WindowsDpapiStore(),
+        "linux-secretservice": LinuxSecretServiceStore(),
+        "plaintext-file": PlaintextFileStore(),
+    }
+    return stores.get(backend_id)
+
+
+def record_keystore_backend(store: KeyStore) -> dict[str, object]:
+    """Persist a verified boot-key backend without replacing a temporary fallback."""
+    existing = _read_backend_state()
+    preference = _backend_preference()
+    if preference == "auto" and existing and existing["backend"] != store.backend_id:
+        return {
+            "recorded": False,
+            "backend": existing["backend"],
+            "fallback_backend": store.backend_id,
+        }
+    payload = {
+        "version": _KEYSTORE_STATE_VERSION,
+        "backend": store.backend_id,
+        "service": _service(),
+    }
+    atomic_write_text(_state_path(), json.dumps(payload, indent=2) + "\n", mode=0o600)
+    return {"recorded": True, "backend": store.backend_id, "fallback_backend": None}
+
+
+def keystore_backend_status() -> dict[str, object]:
+    """Return non-secret diagnostics for the selected and persisted backend."""
+    state = _read_backend_state()
+    selected = resolve_keystore().backend_id
+    pinned = state["backend"] if state else None
+    return {
+        "selected": selected,
+        "pinned": pinned,
+        "fallback_active": bool(pinned and selected != pinned),
+        "preference": _backend_preference(),
+    }
+
+
 def _backend_usable(candidate: KeyStore) -> bool:
     """Return true when a native backend can read the live key or write safely.
 

package/agent-wallet/agent_wallet/sealed_keys.py

@@ -5,7 +5,11 @@ from __future__ import annotations
 import json
 from pathlib import Path
 
-from agent_wallet.encrypted_storage import decrypt_secret_material, encrypt_secret_material
+from agent_wallet.encrypted_storage import (
+    decrypt_secret_material,
+    encrypt_secret_material,
+    remove_envelope_migration_backup,
+)
 from agent_wallet.file_ops import atomic_write_text
 from agent_wallet.wallet_layer.base import WalletBackendError
 
@@ -45,6 +49,7 @@ def seal_keys(boot_key: str, secrets: dict[str, str]) -> Path:
     encrypted = encrypt_secret_material(payload, master_key=boot_key)
     path = resolve_sealed_keys_path()
     atomic_write_text(path, encrypted, mode=0o600)
+    remove_envelope_migration_backup(path)
     clear_unseal_cache()
     return path
 
@@ -79,28 +84,20 @@ def unseal_keys(boot_key: str) -> dict[str, str]:
     for key, value in payload.items():
         if isinstance(key, str) and isinstance(value, str):
             secrets[key] = value
-    _maybe_migrate_envelope_kdf(boot_key, secrets, raw_text)
+    _maybe_migrate_envelope_kdf(boot_key, plaintext, raw_text)
     _unseal_cache.clear()
     _unseal_cache[cache_key] = dict(secrets)
     return secrets
 
 
-def _maybe_migrate_envelope_kdf(boot_key: str, secrets: dict[str, str], raw_text: str) -> None:
-    """Lazily re-seal an argon2id file as hkdf-sha256 after a successful unseal.
+def _maybe_migrate_envelope_kdf(boot_key: str, plaintext: str, raw_text: str) -> None:
+    """Opt-in re-seal of argon2id as HKDF with a verified rollback backup.
 
-    Best-effort: any failure leaves the (still readable) argon2id file in
-    place. The boot key is machine-generated high entropy, so hkdf loses no
-    security while dropping ~1s of KDF per cold process. Rollback caveat:
-    pre-hkdf runtimes cannot read the rewritten file — kill switch is
-    AGENT_WALLET_ENVELOPE_KDF_MIGRATION=0.
+    Normal reads never migrate. Set AGENT_WALLET_ENVELOPE_KDF_MIGRATION=1 to
+    opt in; failures leave the readable original in place.
     """
     from agent_wallet.config import envelope_kdf_migration_enabled
-    from agent_wallet.encrypted_storage import (
-        KDF_ARGON2ID,
-        KDF_HKDF_SHA256,
-        _default_write_kdf,
-        envelope_kdf,
-    )
+    from agent_wallet.encrypted_storage import KDF_ARGON2ID, _default_write_kdf, envelope_kdf
 
     try:
         if not envelope_kdf_migration_enabled():
@@ -109,9 +106,13 @@ def _maybe_migrate_envelope_kdf(boot_key: str, secrets: dict[str, str], raw_text
             return  # forced-argon2id installs must not rewrite in place forever
         if envelope_kdf(raw_text) != KDF_ARGON2ID:
             return
-        payload = json.dumps(secrets, indent=2)
-        encrypted = encrypt_secret_material(payload, master_key=boot_key, kdf=KDF_HKDF_SHA256)
-        atomic_write_text(resolve_sealed_keys_path(), encrypted, mode=0o600)
+        from agent_wallet.encrypted_storage import migrate_envelope_to_hkdf
+
+        migrate_envelope_to_hkdf(
+            resolve_sealed_keys_path(),
+            plaintext,
+            master_key=boot_key,
+        )
         clear_unseal_cache()
     except Exception:
         pass

package/agent-wallet/agent_wallet/user_wallets.py

@@ -183,12 +183,11 @@ def _maybe_migrate_wallet_envelope_kdf(
     key_scope: str | None,
     address: str,
 ) -> None:
-    """Lazily rewrite an argon2id wallet envelope as hkdf-sha256.
+    """Opt-in rewrite of argon2id as HKDF with a verified rollback backup.
 
     Re-encrypts with the SAME key scope that just decrypted the file, so this
-    never performs a scope migration through the back door. Best-effort: any
-    failure leaves the (still readable) argon2id file untouched. Kill switch:
-    AGENT_WALLET_ENVELOPE_KDF_MIGRATION=0.
+    never performs a scope migration through the back door. Normal reads do not
+    mutate storage; opt in with AGENT_WALLET_ENVELOPE_KDF_MIGRATION=1.
     """
     from agent_wallet.config import envelope_kdf_migration_enabled
     from agent_wallet.encrypted_storage import (
@@ -214,7 +213,9 @@ def _maybe_migrate_wallet_envelope_kdf(
             master_key = resolve_wallet_master_key()
         if not master_key.strip():
             return
-        write_encrypted_wallet_file(
+        from agent_wallet.encrypted_storage import migrate_envelope_to_hkdf
+
+        migrate_envelope_to_hkdf(
             path,
             secret_material,
             master_key=master_key,

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

package/agent-wallet/scripts/bootstrap_openclaw_evm.py

@@ -142,9 +142,11 @@ def _auto_start_local_service(
     # steady state is a no-op. See agent_wallet.evm_user_wallets for the shared
     # health/version/stop helpers.
     from agent_wallet.evm_user_wallets import (
+        _expected_local_service_instance_id,
         _service_health,
         _should_restart_local_service,
         _stop_local_service,
+        _write_service_owner,
     )
 
     restarted = False
@@ -152,7 +154,7 @@ def _auto_start_local_service(
     if health is not None:
         if not _should_restart_local_service(health, wallet_root=wdk_wallet_root):
             return {"started": False, "already_healthy": True}
-        _stop_local_service(service_url)
+        _stop_local_service(service_url, health)
         restarted = True
 
     if not _is_local_service_url(service_url):
@@ -175,6 +177,7 @@ def _auto_start_local_service(
     env["HOST"] = host
     env["PORT"] = str(port)
     env["WDK_EVM_NETWORK"] = network
+    env["WDK_EVM_INSTANCE_ID"] = _expected_local_service_instance_id()
 
     with log_path.open("a", encoding="utf-8") as log_file:
         process = subprocess.Popen(  # noqa: S603
@@ -189,12 +192,14 @@ def _auto_start_local_service(
 
     deadline = time.time() + 30.0
     while time.time() < deadline:
-        if _service_is_healthy(service_url):
+        health = _service_health(service_url)
+        if health is not None:
+            pid = _write_service_owner(health, service_url)
             return {
                 "started": True,
                 "already_healthy": False,
                 "restarted": restarted,
-                "pid": process.pid,
+                "pid": pid,
                 "log_path": str(log_path),
             }
         if process.poll() is not None:

package/agent-wallet/scripts/install_agent_wallet.py

@@ -25,6 +25,7 @@ INCLUDED_RUNTIME_ROOT_FILES = [
     "setup.sh",
 ]
 INCLUDED_RUNTIME_TOP_LEVEL_DIRS = [
+    "claude-code",
     "codex",
     ".openclaw",
     "agent-wallet",
@@ -862,6 +863,7 @@ def main() -> None:
     source_wdk_btc_root = Path(args.wdk_btc_root).expanduser().resolve()
     source_wdk_evm_root = Path(args.wdk_evm_root).expanduser().resolve()
     runtime_root = Path(args.runtime_root).expanduser().resolve()
+    final_runtime_root = os.getenv("OPENCLAW_INSTALL_FINAL_ROOT", "").strip()
     config_path = Path(args.config_path).expanduser()
     env_path = Path(args.env_path).expanduser()
     env_example_path = Path(args.env_example_path).expanduser()
@@ -1039,7 +1041,8 @@ def main() -> None:
                 "extension_path": str(extension_path),
                 "wdk_btc_root": str(wdk_btc_root),
                 "wdk_evm_root": str(wdk_evm_root),
-                "runtime_root": str(runtime_root),
+                "runtime_root": final_runtime_root or str(runtime_root),
+                "staging_root": str(runtime_root) if final_runtime_root else None,
                 "install_from_runtime": bool(args.install_from_runtime),
                 "python_bin": str(python_bin),
                 "venv_created": venv_created,