@agentlayer.tech/wallet 0.1.91 → 0.1.93

package/agent-wallet/agent_wallet/boot_key_migration.py

@@ -12,8 +12,8 @@ from pathlib import Path
 
 from agent_wallet.config import (
     read_boot_key_from_keystore,
+    resolve_boot_key,
     resolve_openclaw_home,
-    settings,
 )
 from agent_wallet.file_ops import atomic_write_text
 from agent_wallet.keystore import (
@@ -26,20 +26,6 @@ from agent_wallet.keystore import (
 _ENV_LINE_PREFIX = "AGENT_WALLET_BOOT_KEY="
 
 
-def _read_legacy_boot_key() -> str:
-    """The authoritative live key from legacy sources only (env override -> file)."""
-    direct = os.getenv("AGENT_WALLET_BOOT_KEY", settings.agent_wallet_boot_key).strip()
-    if direct:
-        return direct
-    key_file = os.getenv("AGENT_WALLET_BOOT_KEY_FILE", settings.agent_wallet_boot_key_file).strip()
-    if key_file:
-        try:
-            return Path(key_file).expanduser().read_text(encoding="utf-8").strip()
-        except OSError:
-            return ""
-    return ""
-
-
 def _env_boot_key_value(line: str) -> str | None:
     """Return the boot-key value on an AGENT_WALLET_BOOT_KEY= line, else None."""
     stripped = line.strip()
@@ -140,23 +126,26 @@ def migrate_boot_key_to_keystore() -> dict:
                 "removed_boot_key_file": False, "reason": "no-os-keystore"}
 
     authoritative = read_boot_key_from_keystore()
+    resolved = resolve_boot_key()
     first_time = False
-    if not authoritative:
-        legacy_key = _read_legacy_boot_key()
-        if not legacy_key:
+    if authoritative != resolved:
+        if not resolved:
             return {"migrated": False, "backend": store.backend_id, "swept_env_files": 0,
                     "removed_boot_key_file": False, "reason": "no-legacy-key"}
         try:
-            store.set(BOOT_KEY_ITEM, legacy_key)
+            store.set(BOOT_KEY_ITEM, resolved)
         except Exception as exc:
             return {"migrated": False, "backend": store.backend_id, "swept_env_files": 0,
                     "removed_boot_key_file": False, "reason": f"keystore-set-failed: {exc}"}
         # Verify-before-delete.
-        if store.get(BOOT_KEY_ITEM) != legacy_key:
+        if store.get(BOOT_KEY_ITEM) != resolved:
             return {"migrated": False, "backend": store.backend_id, "swept_env_files": 0,
                     "removed_boot_key_file": False, "reason": "verify-failed"}
-        authoritative = legacy_key
+        authoritative = resolved
         first_time = True
+    elif not authoritative:
+        return {"migrated": False, "backend": store.backend_id, "swept_env_files": 0,
+                "removed_boot_key_file": False, "reason": "no-legacy-key"}
 
     record_keystore_backend(store)
     swept, removed = _sweep_plaintext(home, authoritative)

package/agent-wallet/agent_wallet/config.py

@@ -448,6 +448,19 @@ def read_boot_key_from_keystore() -> str:
         return ""
 
 
+def read_boot_key_from_legacy_unscoped_keystore() -> str:
+    """Read the pre-home-scoping native service for compatibility only."""
+    sealed_path = resolve_openclaw_home() / "sealed_keys.json"
+    if not sealed_path.exists():
+        return ""
+    try:
+        from agent_wallet.keystore import read_legacy_unscoped_boot_key
+
+        return read_legacy_unscoped_boot_key()
+    except Exception:
+        return ""
+
+
 def _read_boot_key_file(path_value: str) -> str:
     if not path_value.strip():
         return ""
@@ -477,6 +490,13 @@ def _boot_key_candidates() -> Iterator[tuple[str, str]]:
     if keystore_item:
         yield keystore_item
 
+    legacy_keystore_item = candidate(
+        "legacy_unscoped_keystore",
+        read_boot_key_from_legacy_unscoped_keystore(),
+    )
+    if legacy_keystore_item:
+        yield legacy_keystore_item
+
     configured_file = os.getenv(
         "AGENT_WALLET_BOOT_KEY_FILE", settings.agent_wallet_boot_key_file
     ).strip()

package/agent-wallet/agent_wallet/evm_user_wallets.py

@@ -200,6 +200,121 @@ def _listening_pids(port: int) -> list[int]:
     return pids
 
 
+def _daemon_takeover_disabled() -> bool:
+    return os.getenv("OPENCLAW_EVM_DISABLE_DAEMON_TAKEOVER", "").strip().lower() in {
+        "1",
+        "true",
+        "yes",
+        "on",
+    }
+
+
+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"
+    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>."
+    )
+
+
+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)
+        return True
+    except ProcessLookupError:
+        return False
+    except PermissionError:
+        return True
+
+
+def _process_released_service(pid: int, port: 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 "")
+    )
+
+
+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
+    try:
+        reported_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
+
+
 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.
 
@@ -212,37 +327,57 @@ def _stop_local_service(service_url: str, health: dict[str, Any] | None = None)
             f"Refusing to stop an unidentified service on port {port}."
         )
     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
+    if _daemon_takeover_disabled():
+        raise WalletBackendError(
+            _takeover_refusal(
+                port,
+                listeners,
+                reported_data_dir,
+                "takeover is disabled by OPENCLAW_EVM_DISABLE_DAEMON_TAKEOVER",
             )
-            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 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)
     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."
+            _takeover_refusal(
+                port,
+                listeners,
+                reported_data_dir,
+                "the listening process could not be identified",
+            )
         )
+
+    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})",
+            )
+        ) from exc
+
     try:
         os.kill(owned_pid, signal.SIGTERM)
     except ProcessLookupError:
@@ -253,20 +388,36 @@ def _stop_local_service(service_url: str, health: dict[str, Any] | None = None)
         ) from exc
     deadline = time.time() + 10.0
     while time.time() < deadline:
-        if _service_health(service_url) is None:
+        if _process_released_service(owned_pid, port, service_url):
             try:
                 _service_owner_path().unlink()
             except FileNotFoundError:
                 pass
             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.
+    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
+    ):
+        raise WalletBackendError(
+            _takeover_refusal(
+                port,
+                _listening_pids(port),
+                str((refreshed_health or {}).get("dataDir") or ""),
+                "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 _service_health(service_url) is None:
+        if _process_released_service(owned_pid, port, service_url):
             try:
                 _service_owner_path().unlink()
             except FileNotFoundError:

package/agent-wallet/agent_wallet/keystore.py

@@ -13,6 +13,7 @@ BOOT_KEY_KEYCHAIN_ARCHITECTURE.md.
 
 from __future__ import annotations
 
+import hashlib
 import json
 import os
 import platform
@@ -36,9 +37,53 @@ _SUBPROCESS_TIMEOUT = 10.0
 
 
 def _service() -> str:
-    """Keychain/Secret-Service service name. Overridable so tests never touch the
-    real shared slot (the OS keychain is global, not scoped to OPENCLAW_HOME)."""
-    return os.getenv("AGENT_WALLET_KEYSTORE_SERVICE", "").strip() or KEYSTORE_SERVICE
+    """Return the keystore namespace for the active wallet home.
+
+    Desktop keystores are global to the OS account, while ``OPENCLAW_HOME`` can
+    point at an isolated test or secondary installation. Keep the historical
+    service for the default home, but derive a stable namespace for every other
+    home so one installation cannot replace another installation's boot key.
+    Tests can still choose a readable throwaway namespace explicitly.
+    """
+    explicit = os.getenv("AGENT_WALLET_KEYSTORE_SERVICE", "").strip()
+    if explicit:
+        return explicit
+    home = resolve_openclaw_home().expanduser().resolve()
+    default_home = (_account_home() / ".openclaw").resolve()
+    if home == default_home:
+        return KEYSTORE_SERVICE
+    home_hash = hashlib.sha256(str(home).encode("utf-8")).hexdigest()[:16]
+    return f"{KEYSTORE_SERVICE}.home-{home_hash}"
+
+
+def _account_home() -> Path:
+    """Return the OS account home without trusting a test-overridden ``HOME``."""
+    if os.name == "nt":
+        user_profile = os.getenv("USERPROFILE", "").strip()
+        if user_profile:
+            return Path(user_profile)
+        drive = os.getenv("HOMEDRIVE", "").strip()
+        home_path = os.getenv("HOMEPATH", "").strip()
+        if drive and home_path:
+            return Path(f"{drive}{home_path}")
+    try:
+        import pwd
+
+        return Path(pwd.getpwuid(os.getuid()).pw_dir)
+    except (ImportError, KeyError, OSError):
+        return Path.home()
+
+
+def _legacy_unscoped_service() -> str | None:
+    """Return the pre-home-scoping service for safe compatibility reads."""
+    if os.getenv("AGENT_WALLET_KEYSTORE_SERVICE", "").strip():
+        return None
+    if _service() == KEYSTORE_SERVICE:
+        return None
+    state = _read_backend_state_payload()
+    if state and state["service"] == KEYSTORE_SERVICE:
+        return KEYSTORE_SERVICE
+    return None
 
 
 def _backend_preference() -> str:
@@ -56,7 +101,7 @@ def _state_path() -> Path:
     return resolve_openclaw_home() / "keystore" / _KEYSTORE_STATE_FILENAME
 
 
-def _read_backend_state() -> dict[str, str] | None:
+def _read_backend_state_payload() -> dict[str, str] | None:
     try:
         payload = json.loads(_state_path().read_text(encoding="utf-8"))
     except (OSError, ValueError):
@@ -72,9 +117,17 @@ def _read_backend_state() -> dict[str, str] | None:
         "plaintext-file",
     }:
         return None
+    return {"backend": backend, "service": service}
+
+
+def _read_backend_state() -> dict[str, str] | None:
+    payload = _read_backend_state_payload()
+    if payload is None:
+        return None
+    service = payload["service"]
     if service != _service():
         return None
-    return {"backend": backend, "service": service}
+    return payload
 
 
 class KeyStoreError(Exception):
@@ -129,11 +182,14 @@ def _run(
 class MacKeychainStore:
     backend_id = "macos-keychain"
 
+    def __init__(self, service: str | None = None) -> None:
+        self.service = service or _service()
+
     def available(self) -> bool:
         return platform.system() == "Darwin" and Path(_SECURITY_BIN).exists()
 
     def get(self, name: str) -> str | None:
-        proc = _run([_SECURITY_BIN, "find-generic-password", "-s", _service(), "-a", name, "-w"])
+        proc = _run([_SECURITY_BIN, "find-generic-password", "-s", self.service, "-a", name, "-w"])
         if proc.returncode != 0:
             return None  # item not found (44) or other non-fatal lookup miss
         value = proc.stdout.rstrip("\n")
@@ -150,17 +206,17 @@ class MacKeychainStore:
         # Trade-off: any process running as this user can read the key without a
         # prompt — the same runtime exposure as a 0600 file. At-rest protection
         # (backups, synced home dirs, a stolen disk) is fully preserved.
-        _run([_SECURITY_BIN, "delete-generic-password", "-s", _service(), "-a", name])
+        _run([_SECURITY_BIN, "delete-generic-password", "-s", self.service, "-a", name])
         proc = _run([
             _SECURITY_BIN, "add-generic-password",
-            "-s", _service(), "-a", name,
+            "-s", self.service, "-a", name,
             "-w", value, "-A",
         ])
         if proc.returncode != 0:
             raise KeyStoreError(f"security add-generic-password failed: {proc.stderr.strip()}")
 
     def delete(self, name: str) -> None:
-        _run([_SECURITY_BIN, "delete-generic-password", "-s", _service(), "-a", name])
+        _run([_SECURITY_BIN, "delete-generic-password", "-s", self.service, "-a", name])
 
 
 class WindowsDpapiStore:
@@ -215,19 +271,22 @@ class WindowsDpapiStore:
 class LinuxSecretServiceStore:
     backend_id = "linux-secretservice"
 
+    def __init__(self, service: str | None = None) -> None:
+        self.service = service or _service()
+
     def available(self) -> bool:
         if platform.system() != "Linux" or shutil.which("secret-tool") is None:
             return False
         # A probe lookup succeeds (rc 0/1) only when a Secret Service answers;
         # a missing/unreachable service errors out (rc >1) or times out.
         try:
-            proc = _run(["secret-tool", "lookup", "service", _service(), "account", "__probe__"])
+            proc = _run(["secret-tool", "lookup", "service", self.service, "account", "__probe__"])
         except subprocess.TimeoutExpired:
             return False
         return proc.returncode in (0, 1)
 
     def get(self, name: str) -> str | None:
-        proc = _run(["secret-tool", "lookup", "service", _service(), "account", name])
+        proc = _run(["secret-tool", "lookup", "service", self.service, "account", name])
         if proc.returncode != 0:
             return None
         value = proc.stdout.rstrip("\n")
@@ -235,15 +294,15 @@ class LinuxSecretServiceStore:
 
     def set(self, name: str, value: str) -> None:
         proc = _run(
-            ["secret-tool", "store", "--label", f"{_service()} {name}",
-             "service", _service(), "account", name],
+            ["secret-tool", "store", "--label", f"{self.service} {name}",
+             "service", self.service, "account", name],
             input_text=value,
         )
         if proc.returncode != 0:
             raise KeyStoreError(f"secret-tool store failed: {proc.stderr.strip()}")
 
     def delete(self, name: str) -> None:
-        _run(["secret-tool", "clear", "service", _service(), "account", name])
+        _run(["secret-tool", "clear", "service", self.service, "account", name])
 
 
 class PlaintextFileStore:
@@ -340,16 +399,52 @@ def _resolve_keystore_uncached() -> KeyStore:
     return PlaintextFileStore()
 
 
-def _store_for_backend(backend_id: str) -> KeyStore | None:
+def _store_for_backend(backend_id: str, *, service: str | None = None) -> KeyStore | None:
     stores: dict[str, KeyStore] = {
-        "macos-keychain": MacKeychainStore(),
+        "macos-keychain": MacKeychainStore(service),
         "windows-dpapi": WindowsDpapiStore(),
-        "linux-secretservice": LinuxSecretServiceStore(),
+        "linux-secretservice": LinuxSecretServiceStore(service),
         "plaintext-file": PlaintextFileStore(),
     }
     return stores.get(backend_id)
 
 
+def read_legacy_unscoped_boot_key() -> str:
+    """Read the historical global service without probing or writing it.
+
+    This is used only as a compatibility candidate for an existing sealed
+    custom-home installation. The caller must verify the value against that
+    home's ``sealed_keys.json`` before accepting or migrating it.
+    """
+    legacy_service = _legacy_unscoped_service()
+    preference = _backend_preference()
+    if not legacy_service or preference in {"plain", "plaintext", "plaintext-file", "file"}:
+        return ""
+
+    if preference in {"macos", "macos-keychain", "keychain"}:
+        candidates: list[KeyStore] = [MacKeychainStore(legacy_service)]
+    elif preference in {"linux", "linux-secretservice", "secretservice"}:
+        candidates = [LinuxSecretServiceStore(legacy_service)]
+    elif preference in {"windows", "windows-dpapi", "dpapi"}:
+        candidates = []
+    else:
+        candidates = [
+            MacKeychainStore(legacy_service),
+            LinuxSecretServiceStore(legacy_service),
+        ]
+
+    for candidate in candidates:
+        try:
+            if not candidate.available():
+                continue
+            value = candidate.get(BOOT_KEY_ITEM)
+            if isinstance(value, str) and value.strip():
+                return value.strip()
+        except Exception:
+            continue
+    return ""
+
+
 def record_keystore_backend(store: KeyStore) -> dict[str, object]:
     """Persist a verified boot-key backend without replacing a temporary fallback."""
     existing = _read_backend_state()

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

@@ -504,7 +504,15 @@ def _requirement_compatibility(requirement: dict[str, Any], backend: AgentWallet
     elif chain == "evm" and scheme == "upto" and not _evm_payment_requirement_supported(requirement):
         reason = "This EVM upto payment is missing a facilitatorAddress in its extra data, so it cannot be signed."
     elif planned_execution_supported and wallet_network_matches:
-        reason = "Wallet network matches, but this backend does not yet expose a supported x402 signer path."
+        if chain == "solana" and getattr(backend, "read_only", False):
+            reason = (
+                "Signer not loaded in this read-only preview context by "
+                "design (avoids unnecessary key material access on cheap "
+                "preview calls) -- the real x402_pay_request call loads "
+                "the signer and can still succeed here."
+            )
+        else:
+            reason = "Wallet network matches, but this backend does not yet expose a supported x402 signer path."
     elif planned_execution_supported:
         reason = "Planned execution path exists, but the requirement targets a different network than the active wallet."
     else:

package/agent-wallet/agent_wallet/user_wallets.py

@@ -528,6 +528,7 @@ def create_openclaw_solana_backend(
             signer=signer,
             address=resolved_address or None,
             sign_only=effective_sign_only,
+            read_only=read_only,
             rpc_provider_mode=str(rpc_config["mode"]),
             rpc_provider=str(rpc_config["provider"]),
             rpc_transport=str(rpc_config["transport"]),
@@ -554,6 +555,7 @@ def create_openclaw_solana_backend(
             signer=None,
             address=wallet_info["address"] or None,
             sign_only=effective_sign_only,
+            read_only=read_only,
             rpc_provider_mode=str(rpc_config["mode"]),
             rpc_provider=str(rpc_config["provider"]),
             rpc_transport=str(rpc_config["transport"]),

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

@@ -261,6 +261,7 @@ class SolanaWalletBackend(AgentWalletBackend):
         signer: SolanaLocalKeypairSigner | None = None,
         address: str | None = None,
         sign_only: bool = True,
+        read_only: bool = False,
         rpc_provider_mode: str | None = None,
         rpc_provider: str | None = None,
         rpc_transport: str | None = None,
@@ -281,6 +282,7 @@ class SolanaWalletBackend(AgentWalletBackend):
         self.commitment = commitment
         self.network = normalize_solana_network(network)
         self.signer = signer
+        self.read_only = read_only
         self.address = final_address
         self.sign_only = sign_only
         self.rpc_provider_mode = rpc_provider_mode

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