@agentlayer.tech/wallet 0.1.11 → 0.1.13

package/agent-wallet/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "openclaw-agent-wallet"
-version = "0.1.11"
+version = "0.1.13"
 description = "Plugin-friendly wallet backend for OpenClaw agents"
 requires-python = ">=3.10"
 dependencies = [

package/agent-wallet/scripts/bootstrap_openclaw_evm.py

@@ -0,0 +1,291 @@
+#!/usr/bin/env python3
+"""One-command host bootstrap for the local OpenClaw EVM wallet flow."""
+
+from __future__ import annotations
+
+import argparse
+import json
+import os
+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]))
+
+from agent_wallet.file_ops import atomic_write_text, chmod_if_exists
+
+
+def _default_config_path() -> Path:
+    return Path(os.path.expanduser("~/.openclaw/openclaw.json"))
+
+
+def _default_user_id() -> str:
+    return f"{os.getenv('USER', 'openclaw-user')}-local"
+
+
+def _default_python_bin() -> str:
+    return os.getenv("OPENCLAW_AGENT_WALLET_PYTHON", sys.executable)
+
+
+def _package_root() -> Path:
+    return Path(__file__).resolve().parents[1]
+
+
+def _repo_root() -> Path:
+    return Path(__file__).resolve().parents[2]
+
+
+def _script_path(name: str) -> Path:
+    return _package_root() / "scripts" / name
+
+
+def _normalize_network(value: str) -> str:
+    network = str(value or "").strip().lower()
+    aliases = {
+        "mainnet": "ethereum",
+        "eth": "ethereum",
+        "eth-mainnet": "ethereum",
+        "base-mainnet": "base",
+        "base_sepolia": "base-sepolia",
+    }
+    network = aliases.get(network, network)
+    if network not in {"ethereum", "sepolia", "base", "base-sepolia"}:
+        return "ethereum"
+    return network
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--config-path", default=str(_default_config_path()))
+    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("--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)
+    parser.add_argument("--python-bin", default=_default_python_bin())
+    parser.add_argument("--package-root", default=str(_package_root()))
+    parser.add_argument("--password-stdin", action=argparse.BooleanOptionalAction, default=False)
+    parser.add_argument("--sign-only", action=argparse.BooleanOptionalAction, default=False)
+    parser.add_argument("--auto-start-service", action=argparse.BooleanOptionalAction, default=True)
+    parser.add_argument("--bind-network-pair", action=argparse.BooleanOptionalAction, default=True)
+    return parser
+
+
+def _ensure_openclaw_config(config_path: Path) -> bool:
+    if config_path.exists():
+        return False
+    config_path.parent.mkdir(parents=True, exist_ok=True)
+    atomic_write_text(
+        config_path,
+        json.dumps({"plugins": {"entries": {}}, "tools": {"alsoAllow": []}}, indent=2) + "\n",
+        mode=0o600,
+    )
+    chmod_if_exists(config_path, 0o600)
+    return True
+
+
+def _run_script(
+    python_bin: str,
+    script_name: str,
+    args: list[str],
+    *,
+    stdin_text: str | None = None,
+) -> dict:
+    completed = subprocess.run(
+        [python_bin, str(_script_path(script_name)), *args],
+        check=True,
+        capture_output=True,
+        text=True,
+        input=stdin_text,
+        env=os.environ.copy(),
+    )
+    return json.loads(completed.stdout)
+
+
+def _health_url(service_url: str) -> str:
+    return f"{service_url.rstrip('/')}/health"
+
+
+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
+
+
+def _is_local_service_url(service_url: str) -> bool:
+    parsed = urlparse(service_url)
+    return parsed.scheme in {"http", "https"} and parsed.hostname in {"127.0.0.1", "localhost", "::1"}
+
+
+def _require_local_service_url(service_url: str) -> None:
+    if not _is_local_service_url(service_url):
+        raise SystemExit(
+            f"EVM bootstrap only supports a localhost service URL. Refusing non-local endpoint: {service_url}"
+        )
+
+
+def _service_log_dir(config_path: Path) -> Path:
+    return config_path.expanduser().parent / "logs"
+
+
+def _service_log_path(config_path: Path) -> Path:
+    return _service_log_dir(config_path) / "wdk-evm-wallet.log"
+
+
+def _auto_start_local_service(
+    *,
+    service_url: str,
+    network: str,
+    wdk_wallet_root: Path,
+    config_path: Path,
+) -> dict[str, object]:
+    if _service_is_healthy(service_url):
+        return {"started": False, "already_healthy": True}
+
+    if not _is_local_service_url(service_url):
+        raise SystemExit(
+            f"EVM service at {service_url} is unreachable and auto-start is only supported for localhost URLs."
+        )
+
+    run_local = wdk_wallet_root / "run-local.sh"
+    if not run_local.exists():
+        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)
+    env["WDK_EVM_NETWORK"] = network
+
+    with log_path.open("a", encoding="utf-8") as log_file:
+        process = subprocess.Popen(  # noqa: S603
+            ["sh", str(run_local)],
+            cwd=str(wdk_wallet_root),
+            env=env,
+            stdin=subprocess.DEVNULL,
+            stdout=log_file,
+            stderr=log_file,
+            start_new_session=True,
+        )
+
+    deadline = time.time() + 30.0
+    while time.time() < deadline:
+        if _service_is_healthy(service_url):
+            return {
+                "started": True,
+                "already_healthy": False,
+                "pid": process.pid,
+                "log_path": str(log_path),
+            }
+        if process.poll() is not None:
+            raise SystemExit(
+                f"wdk-evm-wallet exited before becoming healthy. Check log: {log_path}"
+            )
+        time.sleep(0.5)
+
+    raise SystemExit(
+        f"Timed out waiting for wdk-evm-wallet health at {_health_url(service_url)}. Check log: {log_path}"
+    )
+
+
+def main() -> int:
+    args = build_parser().parse_args()
+    effective_network = _normalize_network(args.network)
+    _require_local_service_url(args.service_url)
+    config_path = Path(args.config_path).expanduser()
+    config_created = _ensure_openclaw_config(config_path)
+    service_bootstrap: dict[str, object] | None = None
+    if args.auto_start_service:
+        service_bootstrap = _auto_start_local_service(
+            service_url=args.service_url,
+            network=effective_network,
+            wdk_wallet_root=Path(args.wdk_wallet_root).expanduser(),
+            config_path=config_path,
+        )
+    elif not _service_is_healthy(args.service_url):
+        raise SystemExit(
+            f"EVM service is not healthy at {_health_url(args.service_url)} and --no-auto-start-service was set."
+        )
+
+    stdin_text = sys.stdin.read() if args.password_stdin else None
+    setup_payload = _run_script(
+        args.python_bin,
+        "manage_openclaw_evm_wallet.py",
+        [
+            "setup",
+            "--user-id",
+            args.user_id,
+            "--network",
+            effective_network,
+            "--service-url",
+            args.service_url,
+            "--label",
+            args.label,
+            "--account-index",
+            str(args.account_index),
+            *([] if not args.password_stdin else ["--password-stdin"]),
+            *(["--bind-network-pair"] if args.bind_network_pair else ["--no-bind-network-pair"]),
+        ],
+        stdin_text=stdin_text,
+    )
+
+    wallet = dict(setup_payload.get("wallet") or {})
+    install_args = [
+        "--config-path",
+        str(config_path),
+        "--plugin-id",
+        args.plugin_id,
+        "--user-id",
+        args.user_id,
+        "--backend",
+        "wdk_evm_local",
+        "--network",
+        effective_network,
+        "--wdk-evm-service-url",
+        args.service_url,
+        "--wdk-evm-wallet-id",
+        str(wallet.get("wallet_id") or ""),
+        "--wdk-evm-account-index",
+        str(wallet.get("account_index") or args.account_index),
+        "--package-root",
+        args.package_root,
+        "--python-bin",
+        args.python_bin,
+        "--sign-only" if args.sign_only else "--no-sign-only",
+    ]
+    install_payload = _run_script(
+        args.python_bin,
+        "install_openclaw_local_config.py",
+        install_args,
+    )
+
+    print(
+        json.dumps(
+            {
+                "ok": True,
+                "config_created": config_created,
+                "service_bootstrap": service_bootstrap,
+                "evm_setup": setup_payload,
+                "openclaw_install": install_payload,
+            }
+        )
+    )
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

package/agent-wallet/scripts/install_agent_wallet.py

@@ -44,6 +44,7 @@ EXCLUDED_RUNTIME_DIR_NAMES = {
 }
 EXCLUDED_RUNTIME_FILE_NAMES = {
     ".DS_Store",
+    ".env",
 }
 EXCLUDED_RUNTIME_SUFFIXES = {
     ".pyc",
@@ -270,6 +271,39 @@ def _ensure_env_file(env_path: Path, env_example_path: Path) -> bool:
     return True
 
 
+def _upsert_env_value(env_path: Path, key: str, value: str) -> bool:
+    if not env_path.exists():
+        return False
+    lines = env_path.read_text(encoding="utf-8").splitlines()
+    updated = False
+    replaced = False
+    prefix = f"{key}="
+    new_line = f"{key}={value}"
+    for index, line in enumerate(lines):
+        if line.startswith(prefix):
+            replaced = True
+            if line != new_line:
+                lines[index] = new_line
+                updated = True
+            break
+    if not replaced:
+        if lines and lines[-1] != "":
+            lines.append("")
+        lines.append(new_line)
+        updated = True
+    if updated:
+        _atomic_write_text(env_path, "\n".join(lines) + "\n", mode=0o600)
+        _chmod_if_exists(env_path, 0o600)
+    return updated
+
+
+def _ensure_runtime_boot_key_file_env(env_path: Path) -> bool:
+    boot_key_file = _resolve_openclaw_home() / "agent-wallet-runtime" / "boot-key"
+    if not boot_key_file.exists():
+        return False
+    return _upsert_env_value(env_path, "AGENT_WALLET_BOOT_KEY_FILE", str(boot_key_file))
+
+
 def _ensure_openclaw_config(config_path: Path) -> bool:
     if config_path.exists():
         return False
@@ -288,6 +322,22 @@ def _venv_python(venv_path: Path) -> Path:
     return venv_path / "bin" / "python"
 
 
+def _venv_python_wrapper(venv_path: Path) -> Path:
+    if os.name == "nt":
+        return _venv_python(venv_path)
+    return venv_path / "bin" / "openclaw-agent-wallet-python"
+
+
+def _ensure_python_wrapper(venv_path: Path) -> Path:
+    if os.name == "nt":
+        return _venv_python(venv_path)
+    wrapper = _venv_python_wrapper(venv_path)
+    wrapper.parent.mkdir(parents=True, exist_ok=True)
+    wrapper.write_text('#!/bin/sh\nexec "$(dirname "$0")/python" "$@"\n', encoding="utf-8")
+    wrapper.chmod(0o755)
+    return wrapper
+
+
 def _ensure_python_runtime(venv_path: Path, package_root: Path) -> tuple[Path, bool]:
     created = False
     python_bin = _venv_python(venv_path)
@@ -299,7 +349,7 @@ def _ensure_python_runtime(venv_path: Path, package_root: Path) -> tuple[Path, b
         [str(python_bin), "-m", "pip", "install", "-e", str(package_root)],
         check=True,
     )
-    return python_bin, created
+    return _ensure_python_wrapper(venv_path), created
 
 
 def _ensure_node_runtime(npm_bin: str, project_root: Path) -> dict[str, object]:
@@ -441,6 +491,7 @@ def main() -> None:
             env_example_path = package_root / ".env.example"
 
     env_created = _ensure_env_file(env_path, env_example_path)
+    boot_key_file_env_updated = _ensure_runtime_boot_key_file_env(env_path)
     config_created = _ensure_openclaw_config(config_path)
 
     python_bin = Path(sys.executable)
@@ -449,7 +500,7 @@ def main() -> None:
         if not args.dry_run:
             python_bin, venv_created = _ensure_python_runtime(venv_path, package_root)
         else:
-            python_bin = _venv_python(venv_path)
+            python_bin = _venv_python_wrapper(venv_path)
 
     node_runtime = {
         "skipped": bool(args.skip_node_setup),
@@ -500,6 +551,7 @@ def main() -> None:
                 "ok": True,
                 "env_path": str(env_path),
                 "env_created": env_created,
+                "boot_key_file_env_updated": boot_key_file_env_updated,
                 "config_path": str(config_path),
                 "config_created": config_created,
                 "package_root": str(package_root),

package/agent-wallet/scripts/install_openclaw_local_config.py

@@ -16,6 +16,25 @@ from agent_wallet.sealed_keys import resolve_sealed_keys_path, seal_keys, unseal
 from security_utils import write_redacted_backup
 
 OPTIONAL_TOOLS = [
+    "get_wallet_capabilities",
+    "get_wallet_address",
+    "get_wallet_balance",
+    "get_active_wallet_backend",
+    "set_wallet_backend",
+    "get_wallet_portfolio",
+    "get_solana_token_prices",
+    "swap_solana_privately",
+    "continue_solana_private_swap",
+    "list_pending_solana_private_swaps",
+    "get_solana_private_swap_status",
+    "get_kamino_lend_markets",
+    "get_kamino_lend_market_reserves",
+    "get_kamino_lend_user_obligations",
+    "get_kamino_lend_user_rewards",
+    "kamino_lend_deposit",
+    "kamino_lend_withdraw",
+    "kamino_lend_borrow",
+    "kamino_lend_repay",
     "sign_wallet_message",
     "transfer_sol",
     "transfer_btc",
@@ -30,20 +49,60 @@ def _default_config_path() -> Path:
     return Path(os.path.expanduser("~/.openclaw/openclaw.json"))
 
 
+def _resolve_openclaw_home() -> Path:
+    return Path(os.path.expanduser(os.getenv("OPENCLAW_HOME", "~/.openclaw")))
+
+
+def _default_runtime_root() -> Path:
+    explicit_target = os.getenv("OPENCLAW_INSTALL_TARGET", "").strip()
+    if explicit_target:
+        return Path(explicit_target).expanduser()
+    explicit_root = os.getenv("OPENCLAW_INSTALL_ROOT", "").strip()
+    if explicit_root:
+        return Path(explicit_root).expanduser() / "current"
+    return _resolve_openclaw_home() / "agent-wallet-runtime" / "current"
+
+
 def _repo_root() -> Path:
     return Path(__file__).resolve().parents[2]
 
 
+def _trusted_runtime_root() -> Path | None:
+    runtime_root = _default_runtime_root().resolve()
+    plugin_manifest = runtime_root / ".openclaw" / "extensions" / "agent-wallet" / "openclaw.plugin.json"
+    package_root = runtime_root / "agent-wallet"
+    if plugin_manifest.exists() and package_root.exists():
+        return runtime_root
+    return None
+
+
 def _default_extension_path() -> Path:
+    runtime_root = _trusted_runtime_root()
+    if runtime_root is not None:
+        return runtime_root / ".openclaw" / "extensions" / "agent-wallet"
     return _repo_root() / ".openclaw" / "extensions" / "agent-wallet"
 
 
 def _default_package_root() -> Path:
+    runtime_root = _trusted_runtime_root()
+    if runtime_root is not None:
+        return runtime_root / "agent-wallet"
     return Path(__file__).resolve().parents[1]
 
 
 def _default_python_bin() -> str:
-    return os.getenv("OPENCLAW_AGENT_WALLET_PYTHON", sys.executable)
+    explicit = os.getenv("OPENCLAW_AGENT_WALLET_PYTHON", "").strip()
+    if explicit:
+        return explicit
+    runtime_root = _trusted_runtime_root()
+    if runtime_root is not None:
+        wrapper = runtime_root / "agent-wallet" / ".runtime-venv" / "bin" / "openclaw-agent-wallet-python"
+        if wrapper.exists():
+            return str(wrapper)
+        runtime_python = runtime_root / "agent-wallet" / ".runtime-venv" / "bin" / "python"
+        if runtime_python.exists():
+            return str(runtime_python)
+    return sys.executable
 
 
 def _default_user_id() -> str:
@@ -64,7 +123,7 @@ def build_parser() -> argparse.ArgumentParser:
     parser = argparse.ArgumentParser(description=__doc__)
     parser.add_argument("--config-path", default=str(_default_config_path()))
     parser.add_argument("--plugin-id", default="agent-wallet")
-    parser.add_argument("--user-id", default=_default_user_id())
+    parser.add_argument("--user-id", default="")
     parser.add_argument("--backend", default="solana_local")
     parser.add_argument("--network", default="devnet")
     parser.add_argument("--rpc-url", default="")
@@ -72,6 +131,9 @@ def build_parser() -> argparse.ArgumentParser:
     parser.add_argument("--wdk-btc-service-url", default="")
     parser.add_argument("--wdk-btc-wallet-id", default="")
     parser.add_argument("--wdk-btc-account-index", type=int, default=0)
+    parser.add_argument("--wdk-evm-service-url", default="")
+    parser.add_argument("--wdk-evm-wallet-id", default="")
+    parser.add_argument("--wdk-evm-account-index", type=int, default=0)
     parser.add_argument("--sign-only", action=argparse.BooleanOptionalAction, default=False)
     parser.add_argument("--encrypt-user-wallets", action=argparse.BooleanOptionalAction, default=True)
     parser.add_argument(
@@ -161,8 +223,20 @@ def main() -> None:
 
     entries = plugins.setdefault("entries", {})
     effective_network = _normalize_network(args.backend, args.network)
+    existing_entry = entries.get(args.plugin_id) if isinstance(entries.get(args.plugin_id), dict) else {}
+    existing_config = (
+        dict(existing_entry.get("config"))
+        if isinstance(existing_entry.get("config"), dict)
+        else {}
+    )
+    resolved_user_id = (
+        args.user_id.strip()
+        or str(existing_config.get("userId") or "").strip()
+        or _default_user_id()
+    )
     plugin_config = {
-        "userId": args.user_id,
+        **existing_config,
+        "userId": resolved_user_id,
         "backend": args.backend,
         "network": effective_network,
         "signOnly": args.sign_only,
@@ -183,6 +257,12 @@ def main() -> None:
         plugin_config["wdkBtcWalletId"] = args.wdk_btc_wallet_id.strip()
     if args.wdk_btc_account_index is not None:
         plugin_config["wdkBtcAccountIndex"] = int(args.wdk_btc_account_index)
+    if args.wdk_evm_service_url.strip():
+        plugin_config["wdkEvmServiceUrl"] = args.wdk_evm_service_url.strip()
+    if args.wdk_evm_wallet_id.strip():
+        plugin_config["wdkEvmWalletId"] = args.wdk_evm_wallet_id.strip()
+    if args.wdk_evm_account_index is not None:
+        plugin_config["wdkEvmAccountIndex"] = int(args.wdk_evm_account_index)
     if args.write_master_key:
         raise SystemExit(
             "Refusing to write masterKey into config. Runtime secrets must live in sealed_keys.json."
@@ -214,7 +294,7 @@ def main() -> None:
                 "python_bin": args.python_bin,
                 "package_root": plugin_config["packageRoot"],
                 "plugin_id": args.plugin_id,
-                "user_id": args.user_id,
+                "user_id": resolved_user_id,
                 "sealed_keys_path": sealed_keys_path,
             },
             indent=2,