@agentlayer.tech/wallet 0.1.12 → 0.1.14

package/agent-wallet/pyproject.toml

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

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

@@ -1,10 +1,11 @@
-"""Patch an OpenClaw config file for the agent-wallet plugin."""
+"""Patch an OpenClaw config file for the AgentLayer OpenClaw plugins."""
 
 from __future__ import annotations
 
 import argparse
 import json
 import os
+import shutil
 import sys
 from datetime import datetime, timezone
 from pathlib import Path
@@ -16,6 +17,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",
@@ -25,25 +45,89 @@ OPTIONAL_TOOLS = [
     "request_devnet_airdrop",
 ]
 
+PAY_BRIDGE_PLUGIN_ID = "pay-bridge"
+PAY_BRIDGE_TOOLS = [
+    "pay_status",
+    "pay_wallet_info",
+    "pay_search_services",
+    "pay_get_service_endpoints",
+    "pay_api_request",
+]
+
 
 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_pay_bridge_extension_path() -> Path:
+    runtime_root = _trusted_runtime_root()
+    if runtime_root is not None:
+        return runtime_root / ".openclaw" / "extensions" / PAY_BRIDGE_PLUGIN_ID
+    return _repo_root() / ".openclaw" / "extensions" / PAY_BRIDGE_PLUGIN_ID
+
+
 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_pay_binary() -> str:
+    explicit = os.getenv("OPENCLAW_PAY_BINARY", "").strip()
+    if explicit:
+        return explicit
+    resolved = shutil.which("pay")
+    return resolved or "pay"
 
 
 def _default_user_id() -> str:
@@ -64,7 +148,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="")
@@ -83,8 +167,10 @@ def build_parser() -> argparse.ArgumentParser:
         default=True,
     )
     parser.add_argument("--extension-path", default=str(_default_extension_path()))
+    parser.add_argument("--pay-bridge-extension-path", default=str(_default_pay_bridge_extension_path()))
     parser.add_argument("--package-root", default=str(_default_package_root()))
     parser.add_argument("--python-bin", default=_default_python_bin())
+    parser.add_argument("--pay-binary", default=_default_pay_binary())
     parser.add_argument("--write-master-key", action=argparse.BooleanOptionalAction, default=False)
     return parser
 
@@ -155,17 +241,37 @@ def main() -> None:
 
     plugins = data.setdefault("plugins", {})
     plugins["enabled"] = True
+    allow = plugins.setdefault("allow", [])
+    if args.plugin_id not in allow:
+        allow.append(args.plugin_id)
+    if PAY_BRIDGE_PLUGIN_ID not in allow:
+        allow.append(PAY_BRIDGE_PLUGIN_ID)
 
     load = plugins.setdefault("load", {})
     paths = load.setdefault("paths", [])
     extension_path_text = str(Path(args.extension_path).expanduser().resolve())
     if extension_path_text not in paths:
         paths.append(extension_path_text)
+    pay_bridge_extension_path_text = str(Path(args.pay_bridge_extension_path).expanduser().resolve())
+    if pay_bridge_extension_path_text not in paths:
+        paths.append(pay_bridge_extension_path_text)
 
     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,
@@ -201,10 +307,25 @@ def main() -> None:
         "enabled": True,
         "config": plugin_config,
     }
+    existing_pay_entry = entries.get(PAY_BRIDGE_PLUGIN_ID) if isinstance(entries.get(PAY_BRIDGE_PLUGIN_ID), dict) else {}
+    existing_pay_config = (
+        dict(existing_pay_entry.get("config"))
+        if isinstance(existing_pay_entry.get("config"), dict)
+        else {}
+    )
+    pay_bridge_config = {
+        **existing_pay_config,
+        "payBinary": args.pay_binary.strip() or _default_pay_binary(),
+        "requireHttps": bool(existing_pay_config.get("requireHttps", True)),
+    }
+    entries[PAY_BRIDGE_PLUGIN_ID] = {
+        "enabled": True,
+        "config": pay_bridge_config,
+    }
 
     tools = data.setdefault("tools", {})
     also_allow = tools.setdefault("alsoAllow", [])
-    for tool_name in OPTIONAL_TOOLS:
+    for tool_name in OPTIONAL_TOOLS + PAY_BRIDGE_TOOLS:
         if tool_name not in also_allow:
             also_allow.append(tool_name)
 
@@ -220,10 +341,11 @@ def main() -> None:
                 "config_path": str(config_path),
                 "backup_path": str(backup_path),
                 "extension_path": extension_path_text,
+                "pay_bridge_extension_path": pay_bridge_extension_path_text,
                 "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,

package/hermes/plugins/agent_wallet/tools.py

@@ -15,6 +15,7 @@ from typing import Any
 
 SECRET_CONFIG_KEYS = {"privateKey", "masterKey", "approvalSecret"}
 BACKENDS = ("solana_local", "wdk_btc_local", "wdk_evm_local")
+PREVIEW_BOUND_SWAP_TOOLS = {"swap_solana_tokens", "swap_solana_privately"}
 
 
 def _json(data: dict[str, Any]) -> str:
@@ -75,12 +76,12 @@ def _prune_preview_cache(cache: dict[str, Any]) -> dict[str, Any]:
 
 
 def _cache_swap_preview(tool_name: str, result: dict[str, Any], ttl_seconds: int = 900) -> None:
-    if tool_name != "swap_solana_tokens" or result.get("ok") is not True:
+    if tool_name not in PREVIEW_BOUND_SWAP_TOOLS or result.get("ok") is not True:
         return
     preview = result.get("data")
     if not isinstance(preview, dict):
         return
-    if preview.get("mode") != "preview" or preview.get("asset_type") != "swap":
+    if preview.get("mode") != "preview" or preview.get("asset_type") not in {"swap", "solana-private-swap"}:
         return
     summary = preview.get("confirmation_summary")
     if not isinstance(summary, dict):
@@ -192,6 +193,85 @@ def _user_id(args: dict[str, Any]) -> str:
     return str(value).strip() or "hermes-local-user"
 
 
+def _normalize_backend(value: Any) -> str:
+    normalized = str(value or "").strip().lower()
+    aliases = {
+        "sol": "solana_local",
+        "solana": "solana_local",
+        "solana_local": "solana_local",
+        "solana-local": "solana_local",
+        "evm": "wdk_evm_local",
+        "ethereum": "wdk_evm_local",
+        "eth": "wdk_evm_local",
+        "base": "wdk_evm_local",
+        "wdk_evm_local": "wdk_evm_local",
+        "wdk-evm-local": "wdk_evm_local",
+        "btc": "wdk_btc_local",
+        "bitcoin": "wdk_btc_local",
+        "wdk_btc_local": "wdk_btc_local",
+        "wdk-btc-local": "wdk_btc_local",
+    }
+    backend = aliases.get(normalized, normalized)
+    if backend not in BACKENDS:
+        raise RuntimeError(
+            "Wallet backend must be one of solana_local, wdk_btc_local, or wdk_evm_local."
+        )
+    return backend
+
+
+def _infer_backend_for_tool(tool_name: str) -> str | None:
+    if (
+        tool_name.startswith("get_evm_")
+        or tool_name.startswith("manage_evm_")
+        or tool_name.startswith("swap_evm_")
+        or tool_name.startswith("transfer_evm_")
+        or tool_name == "agent_wallet_evm_status"
+        or tool_name == "agent_wallet_evm_setup"
+    ):
+        return "wdk_evm_local"
+    if tool_name.startswith("get_btc_") or tool_name == "transfer_btc":
+        return "wdk_btc_local"
+    if (
+        "solana" in tool_name
+        or "jupiter" in tool_name
+        or "kamino" in tool_name
+        or "bags" in tool_name
+        or tool_name in {"transfer_sol", "transfer_spl_token", "sign_wallet_message", "close_empty_token_accounts", "request_devnet_airdrop", "get_wallet_portfolio", "get_solana_token_prices"}
+    ):
+        return "solana_local"
+    return None
+
+
+def _normalize_network_for_backend(backend: str, raw_network: Any) -> str:
+    network = str(raw_network or "").strip().lower()
+    if backend == "wdk_evm_local":
+        aliases = {
+            "mainnet": "ethereum",
+            "eth": "ethereum",
+            "eth-mainnet": "ethereum",
+            "base-mainnet": "base",
+        }
+        normalized = aliases.get(network, network)
+        return normalized if normalized in {"ethereum", "base"} else "ethereum"
+    if backend == "wdk_btc_local":
+        aliases = {
+            "btc": "bitcoin",
+            "bitcoin_mainnet": "bitcoin",
+            "bitcoin-mainnet": "bitcoin",
+            "mainnet": "bitcoin",
+        }
+        normalized = aliases.get(network, network)
+        return normalized if normalized in {"bitcoin", "testnet", "regtest"} else "bitcoin"
+    aliases = {
+        "solana": "mainnet",
+        "solana-mainnet": "mainnet",
+        "mainnet_beta": "mainnet",
+        "mainnet-beta": "mainnet",
+    }
+    normalized = aliases.get(network, network)
+    return normalized if normalized in {"mainnet", "devnet", "testnet"} else "mainnet"
+
+
 def _reject_secret_config(config: dict[str, Any]) -> None:
     present = sorted(key for key in SECRET_CONFIG_KEYS if str(config.get(key) or "").strip())
     if present:
@@ -202,16 +282,20 @@ def _reject_secret_config(config: dict[str, Any]) -> None:
         )
 
 
-def _base_config(args: dict[str, Any]) -> dict[str, Any]:
+def _base_config(args: dict[str, Any], *, tool_name: str | None = None) -> dict[str, Any]:
     raw = args.get("config") or {}
     if not isinstance(raw, dict):
         raise RuntimeError("config must be a JSON object when provided.")
     config = dict(raw)
     backend = args.get("backend") or os.getenv("AGENT_WALLET_BACKEND")
-    network = args.get("network") or os.getenv("AGENT_WALLET_NETWORK")
+    if not backend and tool_name:
+        backend = _infer_backend_for_tool(tool_name)
     if backend:
-        config["backend"] = str(backend).strip()
-    if network:
+        config["backend"] = _normalize_backend(backend)
+    network = args.get("network") or os.getenv("AGENT_WALLET_NETWORK") or config.get("network")
+    if backend:
+        config["network"] = _normalize_network_for_backend(config["backend"], network)
+    elif network:
         config["network"] = str(network).strip()
     _reject_secret_config(config)
     return config
@@ -235,15 +319,15 @@ def _cli_env(package_root: Path) -> dict[str, str]:
 
 def _call_wallet_cli(args: dict[str, Any]) -> dict[str, Any]:
     package_root = _resolve_package_root()
-    config = _base_config(args)
     tool_name = str(args.get("tool_name") or "").strip()
     if not tool_name:
         raise RuntimeError("tool_name is required.")
+    config = _base_config(args, tool_name=tool_name)
 
     tool_args = args.get("arguments") or {}
     if not isinstance(tool_args, dict):
         raise RuntimeError("arguments must be a JSON object when provided.")
-    if tool_name == "swap_solana_tokens" and str(tool_args.get("mode") or "") == "execute":
+    if tool_name in PREVIEW_BOUND_SWAP_TOOLS and str(tool_args.get("mode") or "") == "execute":
         approval_token = str(tool_args.get("approval_token") or "").strip()
         cached_preview = _lookup_preview_for_token(approval_token)
         if cached_preview is not None and "_approved_preview" not in tool_args:
@@ -321,10 +405,10 @@ def _call_issue_approval(args: dict[str, Any]) -> dict[str, Any]:
             "user_confirmed=true is required after explicit user approval of the exact confirmation_summary."
         )
     package_root = _resolve_package_root()
-    config = _base_config(args)
     tool_name = str(args.get("tool_name") or "").strip()
     if not tool_name:
         raise RuntimeError("tool_name is required.")
+    config = _base_config(args, tool_name=tool_name)
 
     summary = args.get("confirmation_summary")
     if not isinstance(summary, dict) or not summary:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agentlayer.tech/wallet",
-  "version": "0.1.12",
+  "version": "0.1.14",
   "description": "NPM installer for the OpenClaw Agent Wallet local runtime.",
   "type": "module",
   "repository": {
@@ -38,6 +38,7 @@
     "agent-wallet/pyproject.toml",
     ".openclaw/AGENTS.md",
     ".openclaw/extensions/agent-wallet/",
+    ".openclaw/extensions/pay-bridge/",
     "hermes/plugins/agent_wallet/",
     "wdk-btc-wallet/src/",
     "wdk-btc-wallet/bootstrap.sh",