@agentlayer.tech/wallet 0.1.48 → 0.1.50

package/agent-wallet/agent_wallet/openclaw_cli.py

@@ -220,6 +220,35 @@ async def _run_issue_approval(
     }
 
 
+def _run_autonomous_permission(action: str, scope: str) -> dict[str, Any]:
+    from agent_wallet import autonomous_permissions
+
+    normalized_scope = str(scope or "").strip()
+    if normalized_scope != autonomous_permissions.BASE_SWAP_SCOPE:
+        raise WalletBackendError("Only scope=base_swaps is currently supported.")
+
+    normalized_action = str(action or "").strip().lower()
+    if normalized_action == "approve":
+        return {
+            "ok": True,
+            "action": normalized_action,
+            "data": autonomous_permissions.approve_base_swaps(approved_by="openclaw_cli"),
+        }
+    if normalized_action == "revoke":
+        return {
+            "ok": True,
+            "action": normalized_action,
+            "data": autonomous_permissions.revoke_base_swaps(),
+        }
+    if normalized_action == "status":
+        return {
+            "ok": True,
+            "action": normalized_action,
+            "data": autonomous_permissions.status(),
+        }
+    raise WalletBackendError("action must be approve, revoke, or status.")
+
+
 async def _run_btc_wallet_get(user_id: str, config: dict[str, Any]) -> dict[str, Any]:
     from agent_wallet.btc_user_wallets import get_user_btc_wallet_binding
 
@@ -433,6 +462,11 @@ def main() -> int:
     approval_parser.add_argument("--ttl-seconds", type=int)
     approval_parser.add_argument("--config-json", default="{}")
 
+    autonomous_permission_parser = subparsers.add_parser("autonomous-permission")
+    autonomous_permission_parser.add_argument("--action", choices=["approve", "revoke", "status"], required=True)
+    autonomous_permission_parser.add_argument("--scope", choices=["base_swaps"], required=True)
+    autonomous_permission_parser.add_argument("--config-json", default="{}")
+
     btc_get_parser = subparsers.add_parser("btc-wallet-get")
     btc_get_parser.add_argument("--user-id", required=True)
     btc_get_parser.add_argument("--config-json", default="{}")
@@ -506,6 +540,8 @@ def main() -> int:
                     ttl_seconds=args.ttl_seconds,
                 )
             )
+        elif args.command == "autonomous-permission":
+            payload = _run_autonomous_permission(args.action, args.scope)
         elif args.command == "btc-wallet-get":
             payload = asyncio.run(_run_btc_wallet_get(args.user_id, config))
         elif args.command == "btc-wallet-create":

package/agent-wallet/agent_wallet/spending_limits.py

@@ -15,6 +15,7 @@ from __future__ import annotations
 
 import threading
 import time
+from collections.abc import Callable
 from dataclasses import dataclass
 
 from agent_wallet.wallet_layer.base import WalletBackendError
@@ -38,9 +39,20 @@ class SpendingConfig:
 class SpendingLedger:
     """Records executed spends and rejects operations that exceed limits."""
 
-    def __init__(self, config: SpendingConfig) -> None:
+    def __init__(
+        self,
+        config: SpendingConfig,
+        *,
+        clock: Callable[[], float] = time.monotonic,
+        entries: list[tuple[float, int]] | None = None,
+    ) -> None:
         self.config = config
-        self._entries: list[tuple[float, int]] = []  # (monotonic-ts, lamports)
+        # (timestamp, lamports) pairs in the unit returned by ``clock``.
+        # Defaults to ``time.monotonic`` for in-process use; pass
+        # ``time.time`` (wall-clock) when entries must be persisted and
+        # reloaded across processes.
+        self._clock = clock
+        self._entries: list[tuple[float, int]] = list(entries or [])
         self._lock = threading.Lock()
 
     # -- public API ----------------------------------------------------------
@@ -51,7 +63,7 @@ class SpendingLedger:
         Raises ``WalletBackendError`` if any limit would be exceeded.
         """
         with self._lock:
-            now = time.monotonic()
+            now = self._clock()
             self._cleanup(now)
 
             # Per-transaction cap
@@ -94,6 +106,12 @@ class SpendingLedger:
 
             self._entries.append((now, lamports))
 
+    def export(self) -> list[tuple[float, int]]:
+        """Return a copy of the (timestamp, lamports) entries for persistence."""
+        with self._lock:
+            self._cleanup(self._clock())
+            return list(self._entries)
+
     # -- internal ------------------------------------------------------------
 
     def _cleanup(self, now: float) -> None:

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.48",
+  "version": "0.1.50",
   "skills": ["skills/wallet-operator"],
   "configSchema": {
     "type": "object",

package/agent-wallet/pyproject.toml

@@ -4,13 +4,13 @@ build-backend = "hatchling.build"
 
 [project]
 name = "openclaw-agent-wallet"
-version = "0.1.48"
+version = "0.1.50"
 description = "Plugin-friendly wallet backend for OpenClaw agents"
 requires-python = ">=3.10"
 dependencies = [
     "fastmcp>=2.0.0",
     "httpx>=0.27.0",
-    "pydantic>=2.0.0",
+    "pydantic>=2.0.0,<2.13.0",
     "pydantic-settings>=2.0.0",
     "pynacl>=1.5.0",
     "python-dotenv>=1.0.0",

package/bin/openclaw-agent-wallet.mjs

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 
-import { spawnSync } from "node:child_process";
+import { spawn, spawnSync } from "node:child_process";
 import crypto from "node:crypto";
 import fs from "node:fs";
 import os from "node:os";
@@ -15,6 +15,14 @@ const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, "utf8"));
 const packageVersion = packageJson.version;
 const UPDATE_CLI_PATH_ENV = "OPENCLAW_AGENT_WALLET_UPDATE_CLI_PATH";
 const UPDATE_PACKAGE_SPEC_ENV = "OPENCLAW_AGENT_WALLET_UPDATE_PACKAGE_SPEC";
+const DEFAULT_PROVIDER_GATEWAY_URL = "https://agent-layer-production.up.railway.app";
+const TELEMETRY_SPOOL_NAME = "telemetry_spool.jsonl";
+const TELEMETRY_ID_NAME = "telemetry_id";
+const TELEMETRY_LAST_FLUSH_NAME = "telemetry_last_flush";
+const TELEMETRY_FLUSH_THROTTLE_SECONDS = 20;
+const TELEMETRY_FORCE_LINES = 25;
+const TELEMETRY_MAX_EVENTS_PER_FLUSH = 100;
+const TELEMETRY_HTTP_TIMEOUT_MS = 1500;
 
 function printHelp() {
   console.log(`openclaw-agent-wallet
@@ -100,6 +108,211 @@ function updateCheckDisabled(env = process.env) {
   return ["1", "true", "yes", "on"].includes(raw);
 }
 
+function telemetryDisabled(env = process.env) {
+  const raw = String(env.AGENT_WALLET_NO_TELEMETRY || "").trim().toLowerCase();
+  return ["1", "true", "yes", "on"].includes(raw);
+}
+
+function telemetryPath(name, env = process.env) {
+  return path.join(resolveOpenclawHome(env), name);
+}
+
+function telemetryInstallId(env = process.env) {
+  const idPath = telemetryPath(TELEMETRY_ID_NAME, env);
+  try {
+    const existing = fs.readFileSync(idPath, "utf8").trim();
+    if (existing) return existing;
+  } catch {
+    // Create below.
+  }
+  const next = crypto.randomUUID ? crypto.randomUUID().replaceAll("-", "") : crypto.randomBytes(16).toString("hex");
+  try {
+    fs.mkdirSync(path.dirname(idPath), { recursive: true });
+    fs.writeFileSync(idPath, next, { mode: 0o600 });
+  } catch {
+    // Telemetry must not affect install flow.
+  }
+  return next;
+}
+
+function telemetryHost(host = "", env = process.env) {
+  const raw = String(host || env.AGENT_WALLET_HOST || "").trim().toLowerCase();
+  return ["claude-code", "codex", "hermes", "openclaw"].includes(raw) ? raw : "unknown";
+}
+
+function telemetrySource(env = process.env) {
+  const explicit = String(env.AGENT_WALLET_INSTALL_SOURCE || "").trim().toLowerCase();
+  if (explicit) return explicit.replace(/[^a-z0-9_]/g, "_").slice(0, 48);
+  return env.npm_execpath || String(env.npm_config_user_agent || "").includes("npm")
+    ? "npx"
+    : "global_cli";
+}
+
+function telemetryGatewayUrl(env = process.env) {
+  return String(env.PROVIDER_GATEWAY_URL || DEFAULT_PROVIDER_GATEWAY_URL).trim().replace(/\/+$/, "");
+}
+
+function telemetryAppend(payload, env = process.env) {
+  const spool = telemetryPath(TELEMETRY_SPOOL_NAME, env);
+  fs.mkdirSync(path.dirname(spool), { recursive: true });
+  fs.appendFileSync(spool, `${JSON.stringify(payload)}\n`, { encoding: "utf8" });
+}
+
+function telemetrySpoolLineCount(env = process.env) {
+  try {
+    const spool = telemetryPath(TELEMETRY_SPOOL_NAME, env);
+    return fs.readFileSync(spool, "utf8").split(/\r?\n/).filter(Boolean).length;
+  } catch {
+    return 0;
+  }
+}
+
+function telemetryShouldFlush(env = process.env) {
+  const count = telemetrySpoolLineCount(env);
+  if (count === 0) return false;
+  if (count >= TELEMETRY_FORCE_LINES) return true;
+  try {
+    const last = Number(fs.readFileSync(telemetryPath(TELEMETRY_LAST_FLUSH_NAME, env), "utf8").trim() || "0");
+    return Date.now() / 1000 - last >= TELEMETRY_FLUSH_THROTTLE_SECONDS;
+  } catch {
+    return true;
+  }
+}
+
+function telemetryMarkFlush(env = process.env) {
+  try {
+    fs.writeFileSync(telemetryPath(TELEMETRY_LAST_FLUSH_NAME, env), String(Date.now() / 1000));
+  } catch {
+    // ignored
+  }
+}
+
+function telemetrySpawnFlush(env = process.env, force = false) {
+  if (!force && !telemetryShouldFlush(env)) return;
+  telemetryMarkFlush(env);
+  try {
+    const child = spawn(process.execPath, [cliPath, "--telemetry-flush"], {
+      detached: true,
+      stdio: "ignore",
+      env,
+    });
+    child.unref();
+  } catch {
+    // ignored
+  }
+}
+
+function recordCliTelemetry(event, { commandName, host = "", ok = true, args = [], flush = true } = {}) {
+  try {
+    if (telemetryDisabled()) return;
+    if (args && hasFlag(args, "--dry-run")) return;
+    const payload = {
+      event,
+      install_id: telemetryInstallId(),
+      host: telemetryHost(host),
+      tool: "",
+      backend: "",
+      plugin_version: packageVersion,
+      ok: Boolean(ok),
+      ts: Math.floor(Date.now() / 1000),
+      source: telemetrySource(),
+      command: String(commandName || "").trim().toLowerCase().replace(/-/g, "_").slice(0, 48),
+    };
+    telemetryAppend(payload);
+    if (flush) telemetrySpawnFlush(process.env, true);
+  } catch {
+    // Telemetry must never affect CLI behavior.
+  }
+}
+
+async function telemetryPost(url, line) {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), TELEMETRY_HTTP_TIMEOUT_MS);
+  try {
+    const response = await fetch(url, {
+      method: "POST",
+      body: line,
+      headers: { "Content-Type": "application/json" },
+      signal: controller.signal,
+    });
+    return response.ok;
+  } catch {
+    return false;
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+async function telemetryFlushMain(env = process.env) {
+  if (telemetryDisabled(env)) return 0;
+  const spool = telemetryPath(TELEMETRY_SPOOL_NAME, env);
+  const claim = `${spool}.flushing.${process.pid}`;
+  try {
+    fs.renameSync(spool, claim);
+  } catch {
+    return 0;
+  }
+
+  let lines = [];
+  try {
+    lines = fs.readFileSync(claim, "utf8").split(/\r?\n/).filter(Boolean);
+  } catch {
+    lines = [];
+  }
+
+  const url = `${telemetryGatewayUrl(env)}/v1/telemetry`;
+  const failed = [];
+  let sent = 0;
+  for (const line of lines) {
+    if (sent >= TELEMETRY_MAX_EVENTS_PER_FLUSH) {
+      failed.push(line);
+      continue;
+    }
+    if (await telemetryPost(url, line)) {
+      sent += 1;
+    } else {
+      failed.push(line);
+    }
+  }
+
+  if (failed.length) {
+    try {
+      fs.appendFileSync(spool, `${failed.join("\n")}\n`, { encoding: "utf8" });
+    } catch {
+      // ignored
+    }
+  }
+  try {
+    fs.unlinkSync(claim);
+  } catch {
+    // ignored
+  }
+  return 0;
+}
+
+function runWithCliTelemetry(fn, { startEvent, successEvent, failedEvent, commandName, host = "", args = [] }) {
+  recordCliTelemetry(startEvent, { commandName, host, ok: true, args, flush: false });
+  let code;
+  try {
+    code = fn();
+  } catch (error) {
+    recordCliTelemetry(failedEvent, {
+      commandName,
+      host,
+      ok: false,
+      args,
+    });
+    throw error;
+  }
+  recordCliTelemetry(code === 0 ? successEvent : failedEvent, {
+    commandName,
+    host,
+    ok: code === 0,
+    args,
+  });
+  return code;
+}
+
 // Shared with the Python runtime (agent_wallet/update_check.py): the cache lives
 // under OPENCLAW_HOME/agent-wallet-runtime regardless of OPENCLAW_INSTALL_ROOT.
 function updateCheckCachePath(env = process.env) {
@@ -1802,6 +2015,10 @@ function runClaudeCodeInstall(args) {
 const args = process.argv.slice(2);
 const command = args[0] || "install";
 
+if (command === "--telemetry-flush") {
+  process.exit(await telemetryFlushMain());
+}
+
 if (command === "--help" || command === "-h" || command === "help") {
   printHelp();
   process.exit(0);
@@ -1830,11 +2047,35 @@ if (command === "status") {
 }
 
 if (command === "install" || command === "setup") {
-  process.exit(runInstall(args.slice(1), { commandName: "install" }));
+  const commandArgs = args.slice(1);
+  process.exit(
+    runWithCliTelemetry(
+      () => runInstall(commandArgs, { commandName: "install" }),
+      {
+        startEvent: "install_start",
+        successEvent: "install_success",
+        failedEvent: "install_failed",
+        commandName: "install",
+        args: commandArgs,
+      },
+    ),
+  );
 }
 
 if (command === "update") {
-  process.exit(runUpdate(args.slice(1)));
+  const commandArgs = args.slice(1);
+  process.exit(
+    runWithCliTelemetry(
+      () => runUpdate(commandArgs),
+      {
+        startEvent: "update_start",
+        successEvent: "update_success",
+        failedEvent: "update_failed",
+        commandName: "update",
+        args: commandArgs,
+      },
+    ),
+  );
 }
 
 if (command === "rollback") {
@@ -1844,7 +2085,20 @@ if (command === "rollback") {
 if (command === "hermes") {
   const subcommand = args[1] || "install";
   if (subcommand === "install" || subcommand === "setup") {
-    process.exit(runHermesInstall(args.slice(2)));
+    const commandArgs = args.slice(2);
+    process.exit(
+      runWithCliTelemetry(
+        () => runHermesInstall(commandArgs),
+        {
+          startEvent: "plugin_install_start",
+          successEvent: "plugin_install_success",
+          failedEvent: "plugin_install_failed",
+          commandName: "hermes_install",
+          host: "hermes",
+          args: commandArgs,
+        },
+      ),
+    );
   }
   console.error(`Unknown hermes command: ${subcommand}`);
   console.error("Run `openclaw-agent-wallet hermes install --yes` to connect Hermes Agent.");
@@ -1854,7 +2108,20 @@ if (command === "hermes") {
 if (command === "codex") {
   const subcommand = args[1] || "install";
   if (subcommand === "install" || subcommand === "setup") {
-    process.exit(runCodexInstall(args.slice(2)));
+    const commandArgs = args.slice(2);
+    process.exit(
+      runWithCliTelemetry(
+        () => runCodexInstall(commandArgs),
+        {
+          startEvent: "plugin_install_start",
+          successEvent: "plugin_install_success",
+          failedEvent: "plugin_install_failed",
+          commandName: "codex_install",
+          host: "codex",
+          args: commandArgs,
+        },
+      ),
+    );
   }
   console.error(`Unknown codex command: ${subcommand}`);
   console.error("Run `openclaw-agent-wallet codex install --yes` to connect Codex.");
@@ -1864,7 +2131,20 @@ if (command === "codex") {
 if (command === "claude-code") {
   const subcommand = args[1] || "install";
   if (subcommand === "install" || subcommand === "setup") {
-    process.exit(runClaudeCodeInstall(args.slice(2)));
+    const commandArgs = args.slice(2);
+    process.exit(
+      runWithCliTelemetry(
+        () => runClaudeCodeInstall(commandArgs),
+        {
+          startEvent: "plugin_install_start",
+          successEvent: "plugin_install_success",
+          failedEvent: "plugin_install_failed",
+          commandName: "claude_code_install",
+          host: "claude-code",
+          args: commandArgs,
+        },
+      ),
+    );
   }
   console.error(`Unknown claude-code command: ${subcommand}`);
   console.error("Run `openclaw-agent-wallet claude-code install --yes` to connect Claude Code.");
@@ -1872,7 +2152,18 @@ if (command === "claude-code") {
 }
 
 if (command.startsWith("-")) {
-  process.exit(runInstall(args, { commandName: "install" }));
+  process.exit(
+    runWithCliTelemetry(
+      () => runInstall(args, { commandName: "install" }),
+      {
+        startEvent: "install_start",
+        successEvent: "install_success",
+        failedEvent: "install_failed",
+        commandName: "install",
+        args,
+      },
+    ),
+  );
 }
 
 console.error(`Unknown command: ${command}`);

package/claude-code/plugins/agent-wallet/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "agent-wallet",
   "displayName": "Agent Wallet",
-  "version": "0.1.48",
+  "version": "0.1.50",
   "description": "Claude Code bridge for the existing AgentLayer wallet runtime. Connects to Solana, Bitcoin, and EVM wallets without creating a new one.",
   "author": {
     "name": "AgentLayer"

package/claude-code/plugins/agent-wallet/README.md

@@ -51,6 +51,11 @@ no-op once the backend is healthy.
 - `/wallet-setup` — install (or repair) the backend explicitly instead of
   waiting for the hook (requires `/reload-plugins` first so the command is
   registered).
+- `/agentlayer-autonomous-approve` — enable high-trust autonomous Base swaps
+  (`swap_evm_tokens` / `swap_evm_uniswap_tokens` on Base only) without
+  per-transaction approvals.
+- `/agentlayer-autonomous-revoke` — disable that autonomous Base swap
+  permission.
 - `AGENT_WALLET_AUTO_BOOTSTRAP=0` — opt out of the auto-install: the
   `SessionStart` hook then only reminds you to run `/wallet-setup` instead of
   installing the backend itself.

package/claude-code/plugins/agent-wallet/commands/agentlayer-autonomous-approve.md

@@ -0,0 +1,24 @@
+---
+description: Enable AgentLayer autonomous Base swaps without per-transaction approvals.
+allowed-tools: mcp__agent_wallet__agentlayer_autonomous_approve, mcp__agent_wallet__agentlayer_autonomous_status
+---
+
+Enable high-trust autonomous Base swaps for AgentLayer.
+
+Call `agentlayer_autonomous_approve` with:
+
+```json
+{
+  "scope": "base_swaps",
+  "purpose": "User requested autonomous Base swaps from Claude Code.",
+  "user_intent": true
+}
+```
+
+Then call `agentlayer_autonomous_status` and report whether `base_swaps` is enabled.
+
+Be explicit in the response:
+
+- This only removes per-transaction approvals for Base Velora/Uniswap swap execute calls.
+- It does not authorize transfers, withdrawals, lending, staking, bridges, Solana swaps, or non-Base networks.
+- The user can run `/agentlayer-autonomous-revoke` to disable it.

package/claude-code/plugins/agent-wallet/commands/agentlayer-autonomous-revoke.md

@@ -0,0 +1,16 @@
+---
+description: Disable AgentLayer autonomous Base swaps.
+allowed-tools: mcp__agent_wallet__agentlayer_autonomous_revoke, mcp__agent_wallet__agentlayer_autonomous_status
+---
+
+Disable high-trust autonomous Base swaps for AgentLayer.
+
+Call `agentlayer_autonomous_revoke` with:
+
+```json
+{
+  "scope": "base_swaps"
+}
+```
+
+Then call `agentlayer_autonomous_status` and report whether `base_swaps` is disabled.

package/claude-code/plugins/agent-wallet/scripts/bootstrap_backend.sh

@@ -113,7 +113,7 @@ fi
 
 log "Installing the AgentLayer wallet backend runtime via npm (this may take a minute)…"
 log "  -> npx $PACKAGE_SPEC install --yes"
-if ! npx -y "$PACKAGE_SPEC" install --yes; then
+if ! AGENT_WALLET_INSTALL_SOURCE=claude_marketplace_bootstrap npx -y "$PACKAGE_SPEC" install --yes; then
   log "Backend install failed. Ensure Node.js 18+ and Python >= 3.10 (with venv) are installed, then re-run /wallet-setup."
   exit 1
 fi
@@ -123,7 +123,7 @@ fi
 # --skip-enable: the plugin is already registered via the marketplace, so we only
 # want the file pinning, not another `claude plugin install`.
 log "Wiring the Claude Code bridge to the installed runtime…"
-npx -y "$PACKAGE_SPEC" claude-code install --yes --skip-enable || \
+AGENT_WALLET_INSTALL_SOURCE=claude_marketplace_bootstrap npx -y "$PACKAGE_SPEC" claude-code install --yes --skip-enable || \
   log "Note: could not re-pin the Claude Code bridge automatically; it will still resolve the default runtime."
 
 if backend_ready; then

package/codex/plugins/agent-wallet/.codex-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-wallet",
-  "version": "0.1.48",
+  "version": "0.1.50",
   "description": "Codex plugin bridge for the AgentLayer wallet runtime.",
   "author": {
     "name": "AgentLayer"

package/codex/plugins/agent-wallet/server.py

@@ -59,6 +59,7 @@ PREVIEW_BOUND_SWAP_TOOLS = {
     "flash_trade_open_position",
     "flash_trade_close_position",
 }
+AUTONOMOUS_BASE_SWAP_TOOLS = {"swap_evm_tokens", "swap_evm_uniswap_tokens"}
 APPROVAL_PREVIEW_TOOL_ALIASES = {
     "x402_pay_request": "x402_preview_request",
 }
@@ -642,6 +643,21 @@ def _requires_approved_preview_payload(tool_name: str, params: dict[str, Any]) -
     return tool_name in PREVIEW_BOUND_SWAP_TOOLS
 
 
+def _should_let_backend_authorize_autonomous_base_swap(
+    tool_name: str,
+    params: dict[str, Any],
+    config: dict[str, Any],
+) -> bool:
+    if tool_name not in AUTONOMOUS_BASE_SWAP_TOOLS:
+        return False
+    if str(params.get("mode") or "") != "execute":
+        return False
+    if str(params.get("approval_token") or "").strip():
+        return False
+    network = str(params.get("network") or config.get("network") or selected_evm_network or "").strip().lower()
+    return network == "base"
+
+
 def _looks_like_approval_context_error(message: str) -> bool:
     text = str(message or "").lower()
     return any(
@@ -696,6 +712,8 @@ def _attach_approval_for_execute(
             effective_params["_approved_preview"] = cached_preview
     if effective_params.get("approval_token"):
         return None
+    if _should_let_backend_authorize_autonomous_base_swap(tool_name, effective_params, config):
+        return None
     raise RuntimeError(APPROVAL_CONTEXT_MISSING_MESSAGE)
 
 

package/hermes/plugins/agent_wallet/plugin.yaml

@@ -1,5 +1,5 @@
 name: agent-wallet
-version: 0.1.48
+version: 0.1.50
 description: Thin Hermes Agent bridge to the existing AgentLayer/OpenClaw wallet backend
 provides_tools:
   - agent_wallet_tools

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agentlayer.tech/wallet",
-  "version": "0.1.48",
+  "version": "0.1.50",
   "description": "NPM installer for the OpenClaw Agent Wallet local runtime.",
   "type": "module",
   "repository": {

package/wdk-btc-wallet/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wdk-btc-wallet",
-  "version": "0.1.48",
+  "version": "0.1.50",
   "private": true,
   "type": "module",
   "description": "Separate BTC-only wallet service built on Tether WDK.",

package/wdk-evm-wallet/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wdk-evm-wallet",
-  "version": "0.1.48",
+  "version": "0.1.50",
   "private": true,
   "type": "module",
   "description": "Separate EVM wallet service built on Tether WDK.",