@agentlayer.tech/wallet 0.1.30 → 0.1.32

package/agent-wallet/openclaw.plugin.json

@@ -117,10 +117,6 @@
         "type": "string",
         "description": "Optional Jupiter Portfolio API base URL for Jupiter-specific positions and staking data."
       },
-      "jupiterLendBaseUrl": {
-        "type": "string",
-        "description": "Optional Jupiter Lend API base URL for Earn read and deposit/withdraw flows."
-      },
       "jupiterApiKey": {
         "type": "string",
         "description": "Optional Jupiter API key if your deployment uses a keyed endpoint."

package/agent-wallet/pyproject.toml

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

package/agent-wallet/scripts/install_agent_wallet.py

@@ -182,6 +182,7 @@ def build_parser() -> argparse.ArgumentParser:
     parser.add_argument("--extension-path", default=str(_extension_path()))
     parser.add_argument("--wdk-btc-root", default=str(_default_wdk_btc_root()))
     parser.add_argument("--wdk-evm-root", default=str(_default_wdk_evm_root()))
+    parser.add_argument("--wdk-evm-service-url", default=EVM_DEFAULT_SERVICE_URL)
     parser.add_argument("--runtime-root", default=str(_default_runtime_root()))
     parser.add_argument("--npm-bin", default=_default_npm_bin())
     parser.add_argument("--plugin-id", default="agent-wallet")
@@ -665,6 +666,9 @@ def _build_next_steps(
     command.extend(["--extension-path", str(effective_extension_path)])
     command.extend(["--package-root", str(effective_package_root)])
     command.extend(["--python-bin", str(python_bin)])
+    if _is_evm_backend(args.backend):
+        service_url = str(getattr(args, "wdk_evm_service_url", "") or EVM_DEFAULT_SERVICE_URL).strip()
+        command.extend(["--wdk-evm-service-url", service_url or EVM_DEFAULT_SERVICE_URL])
     return command
 
 
@@ -672,18 +676,51 @@ def _is_solana_backend(backend: str) -> bool:
     return backend.strip().lower() in {"solana", "solana_local", "solana-local"}
 
 
+def _is_evm_backend(backend: str) -> bool:
+    return backend.strip().lower() in {
+        "wdk_evm_local",
+        "wdk-evm-local",
+        "evm_local",
+        "evm-local",
+    }
+
+
+EVM_DEFAULT_SERVICE_URL = "http://127.0.0.1:8081"
+
+
+def _build_evm_onboard_config(args: argparse.Namespace) -> dict[str, object]:
+    # The EVM wallet is provisioned on every install (best-effort). Seed creation
+    # with a valid EVM network; ensure_user_evm_wallet_ready binds BOTH base and
+    # ethereum (one address), so the active --network only matters when EVM is the
+    # active backend.
+    network = args.network.strip().lower() if _is_evm_backend(args.backend) else "base"
+    if network not in {"base", "ethereum"}:
+        network = "base"
+    service_url = str(getattr(args, "wdk_evm_service_url", "") or EVM_DEFAULT_SERVICE_URL).strip()
+    return {
+        "backend": "wdk_evm_local",
+        "network": network,
+        "signOnly": bool(args.sign_only),
+        "wdkEvmServiceUrl": service_url or EVM_DEFAULT_SERVICE_URL,
+    }
+
+
 def _build_solana_onboard_config(args: argparse.Namespace) -> dict[str, object]:
+    # Solana is provisioned on every install (both wallets are created), so force
+    # the Solana backend/network here -- this must work even when the active
+    # backend chosen by the user is EVM or BTC.
+    solana_active = _is_solana_backend(args.backend)
     config: dict[str, object] = {
-        "backend": args.backend,
-        "network": args.network,
+        "backend": "solana_local",
+        "network": "mainnet",
         "signOnly": bool(args.sign_only),
         "encryptUserWallets": True,
         "migratePlaintextUserWallets": True,
         "refuseMainnetWalletRecreation": True,
     }
-    if args.rpc_url.strip():
+    if solana_active and args.rpc_url.strip():
         config["rpcUrl"] = args.rpc_url.strip()
-    if args.rpc_urls.strip():
+    if solana_active and args.rpc_urls.strip():
         config["rpcUrls"] = [item.strip() for item in args.rpc_urls.split(",") if item.strip()]
     return config
 
@@ -708,8 +745,6 @@ def _bootstrap_solana_wallet(
     package_root: Path,
     args: argparse.Namespace,
 ) -> dict[str, object] | None:
-    if not _is_solana_backend(args.backend):
-        return None
     result = subprocess.run(
         [
             str(python_bin),
@@ -741,6 +776,60 @@ def _bootstrap_solana_wallet(
     }
 
 
+def _bootstrap_evm_wallet(
+    python_bin: Path,
+    package_root: Path,
+    args: argparse.Namespace,
+    wdk_evm_root: Path,
+) -> dict[str, object]:
+    """Provision the local EVM wallet (best-effort).
+
+    Mirrors _bootstrap_solana_wallet but for wdk_evm_local. Runs the onboard CLI,
+    which calls ensure_user_evm_wallet_ready: auto-starts the local Node service,
+    creates and seals the wallet password, and binds both base and ethereum.
+    Failures here never abort the install -- the lazy runtime path (ensure_ready on
+    first EVM use) remains the safety net.
+    """
+    env = _runtime_env_for_onboard(package_root)
+    env["OPENCLAW_EVM_WDK_WALLET_ROOT"] = str(wdk_evm_root)
+    try:
+        result = subprocess.run(
+            [
+                str(python_bin),
+                "-m",
+                "agent_wallet.openclaw_cli",
+                "onboard",
+                "--user-id",
+                args.user_id,
+                "--config-json",
+                json.dumps(_build_evm_onboard_config(args)),
+            ],
+            cwd=package_root,
+            capture_output=True,
+            text=True,
+            check=True,
+            env=env,
+        )
+    except subprocess.CalledProcessError as exc:
+        detail = (exc.stderr or exc.stdout or str(exc)).strip()
+        return {"ok": False, "error": detail[-2000:]}
+    try:
+        payload = json.loads(result.stdout)
+    except json.JSONDecodeError:
+        return {"ok": False, "error": "EVM onboard returned non-JSON output."}
+    session = dict(payload.get("session") or {})
+    wallet_path = str(session.get("wallet_path") or "")
+    wallet_id = wallet_path.split("walletId=", 1)[-1] if "walletId=" in wallet_path else None
+    return {
+        "ok": True,
+        "user_id": session.get("user_id") or args.user_id,
+        "address": session.get("address"),
+        "wallet_id": wallet_id,
+        "networks": ["base", "ethereum"],
+        "backend": session.get("backend"),
+    }
+
+
 def main() -> None:
     args = build_parser().parse_args()
     source_package_root = Path(args.package_root).expanduser().resolve()
@@ -873,6 +962,7 @@ def main() -> None:
     configured = False
     configure_stdout = ""
     solana_onboard_result: dict[str, object] | None = None
+    evm_onboard_result: dict[str, object] | None = None
     if backend_enabled and not pending_env and not args.dry_run:
         result = subprocess.run(
             _build_next_steps(
@@ -893,6 +983,22 @@ def main() -> None:
             package_root,
             args,
         )
+        # Both wallets are provisioned on every install. EVM provisioning is
+        # best-effort: a failure here must not abort the install, since the lazy
+        # runtime path will create the wallet on first EVM use.
+        evm_onboard_result = _bootstrap_evm_wallet(
+            python_bin,
+            package_root,
+            args,
+            wdk_evm_root,
+        )
+        if isinstance(evm_onboard_result, dict) and not evm_onboard_result.get("ok"):
+            print(
+                "warning: the EVM wallet was not provisioned during install; it will "
+                "be created automatically on first EVM use. Details: "
+                + str(evm_onboard_result.get("error") or "unknown"),
+                file=sys.stderr,
+            )
 
     print(
         json.dumps(
@@ -918,6 +1024,7 @@ def main() -> None:
                 "configured": configured,
                 "pending_env": pending_env,
                 "solana_wallet": solana_onboard_result,
+                "evm_wallet": evm_onboard_result,
                 "next_configure_command": _build_next_steps(
                     python_bin,
                     install_config_script,

package/agent-wallet/scripts/install_openclaw_local_config.py

@@ -13,7 +13,11 @@ from pathlib import Path
 sys.path.insert(0, str(Path(__file__).resolve().parents[1]))
 
 from agent_wallet.file_ops import atomic_write_text, chmod_if_exists
-from agent_wallet.config import normalize_btc_network, normalize_solana_network
+from agent_wallet.config import (
+    normalize_btc_network,
+    normalize_evm_network,
+    normalize_solana_network,
+)
 from agent_wallet.sealed_keys import resolve_sealed_keys_path, seal_keys, unseal_keys
 from security_utils import write_redacted_backup
 
@@ -25,10 +29,6 @@ LEGACY_ALLOWLIST_TOOLS = [
     "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",
@@ -182,6 +182,8 @@ def _normalize_network(backend: str, network: str) -> str:
     normalized = network.strip().lower()
     if backend_name in {"wdk_btc_local", "wdk-btc-local", "btc_local", "btc-local"}:
         return normalize_btc_network(normalized or "bitcoin")
+    if backend_name in {"wdk_evm_local", "wdk-evm-local", "evm_local", "evm-local"}:
+        return normalize_evm_network(normalized or "ethereum")
     return normalize_solana_network(normalized or "mainnet")
 
 

package/agent-wallet/skills/wallet-operator/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: wallet-operator
-description: Use when operating OpenClaw wallet tools: balances, transfers, swaps, LI.FI cross-chain swaps, Jupiter swaps, Velora EVM swaps, BTC transfers, staking, Jupiter Earn, Kamino lending, Bags claims/launches, and wallet execution safety.
+description: Use when operating OpenClaw wallet tools: balances, transfers, swaps, LI.FI cross-chain swaps, Jupiter swaps, Velora EVM swaps, BTC transfers, staking, Kamino lending, Bags claims/launches, and wallet execution safety.
 ---
 
 # Wallet Operator
@@ -29,7 +29,6 @@ Use this skill before calling OpenClaw wallet tools. It is the routing guide for
 - EVM transfers: `transfer_evm_native`, `transfer_evm_token`.
 - BTC transfer: `transfer_btc`.
 - Solana staking: `stake_sol_native`, `deactivate_solana_stake`, `withdraw_solana_stake`.
-- Jupiter Earn: `jupiter_earn_deposit`, `jupiter_earn_withdraw`.
 - Kamino: `kamino_lend_deposit`, `kamino_lend_withdraw`, `kamino_lend_borrow`, `kamino_lend_repay`.
 - Bags: `claim_bags_fees`, `launch_bags_token`.
 
@@ -107,9 +106,6 @@ Use this skill before calling OpenClaw wallet tools. It is the routing guide for
 - `stake_sol_native`: `vote_account`, `amount` in SOL, `mode`, `purpose`.
 - `deactivate_solana_stake`: `stake_account`, `mode`, `purpose`.
 - `withdraw_solana_stake`: `stake_account`, `amount` in SOL, optional `recipient`, `mode`, `purpose`.
-- Before Jupiter Earn writes, use `get_jupiter_earn_tokens`, `get_jupiter_earn_positions`, and `get_jupiter_earn_earnings`.
-- `jupiter_earn_deposit`: `asset` mint, `amount_raw`, `mode`, `purpose`.
-- `jupiter_earn_withdraw`: `asset` mint, `amount_raw`, `mode`, `purpose`.
 - Before Kamino writes, use `get_kamino_lend_markets`, `get_kamino_lend_market_reserves`, `get_kamino_lend_user_obligations`, and `get_kamino_lend_user_rewards`.
 - Kamino write params: `market`, `reserve`, `amount_ui` decimal string, `mode`, `purpose`.
 - Bags reads: `get_bags_claimable_positions`, `get_bags_fee_analytics`.

package/bin/openclaw-agent-wallet.mjs

@@ -1268,71 +1268,138 @@ function runCodexInstall(args) {
   return add.skipped || add.ok ? 0 : 1;
 }
 
-function runClaudeCodeInstall(args) {
-  const pluginSource = resolveClaudeCodePluginSource();
-  const force = hasFlag(args, "--force");
-  const skipEnable = hasFlag(args, "--skip-enable");
-  const claudeBin = commandPath("claude");
+const CLAUDE_CODE_MARKETPLACE_NAME = "agentlayer-local";
 
-  // Symlink the plugin into ~/.claude/plugins/agent-wallet so Claude Code can load it.
-  const pluginInstallDir = path.join(os.homedir(), ".claude", "plugins");
-  const pluginTarget = path.join(pluginInstallDir, "agent-wallet");
+function resolveClaudeCodeMarketplaceDir(env = process.env) {
+  return path.resolve(
+    expandHome(env.AGENT_WALLET_CLAUDE_CODE_MARKETPLACE_DIR || "~/.claude/agentlayer-local"),
+  );
+}
+
+function ensureClaudeCodeMarketplace(marketplaceDir, pluginSource, force) {
+  const pluginsDir = path.join(marketplaceDir, "plugins");
+  const pluginLink = path.join(pluginsDir, "agent-wallet");
+  const manifestDir = path.join(marketplaceDir, ".claude-plugin");
+  const manifestPath = path.join(manifestDir, "marketplace.json");
 
-  fs.mkdirSync(pluginInstallDir, { recursive: true });
+  fs.mkdirSync(pluginsDir, { recursive: true });
+  fs.mkdirSync(manifestDir, { recursive: true });
+
+  // Symlink plugin source into marketplace plugins dir.
   try {
-    const existing = fs.lstatSync(pluginTarget);
+    const existing = fs.lstatSync(pluginLink);
     if (!existing.isSymbolicLink()) {
       if (!force) {
-        throw new Error(`${pluginTarget} exists and is not a symlink. Pass --force to replace it.`);
+        throw new Error(
+          `${pluginLink} exists and is not a symlink. Pass --force to replace it.`,
+        );
       }
-      fs.rmSync(pluginTarget, { recursive: true, force: true });
+      fs.rmSync(pluginLink, { recursive: true, force: true });
     } else {
-      fs.unlinkSync(pluginTarget);
+      fs.unlinkSync(pluginLink);
     }
   } catch (error) {
     if (error?.code !== "ENOENT") throw error;
   }
-  fs.symlinkSync(pluginSource, pluginTarget, "dir");
+  fs.symlinkSync(pluginSource, pluginLink, "dir");
+
+  // Write marketplace manifest (Claude Code requires owner + plugins[].source as relative path).
+  const manifest = {
+    name: CLAUDE_CODE_MARKETPLACE_NAME,
+    description: "Local AgentLayer plugins",
+    owner: { name: "AgentLayer" },
+    plugins: [
+      {
+        name: "agent-wallet",
+        displayName: "Agent Wallet",
+        description:
+          "Bridge to the existing local AgentLayer wallet runtime (Solana, Bitcoin, EVM).",
+        category: "development",
+        source: "./plugins/agent-wallet",
+      },
+    ],
+  };
+  writeJsonFile(manifestPath, manifest);
+  return { pluginLink, manifestPath };
+}
+
+function runClaudeCodeInstall(args) {
+  const pluginSource = resolveClaudeCodePluginSource();
+  const force = hasFlag(args, "--force");
+  const skipEnable = hasFlag(args, "--skip-enable");
+  const claudeBin = commandPath("claude");
+  const marketplaceDir = resolveClaudeCodeMarketplaceDir();
+
+  const { pluginLink } = ensureClaudeCodeMarketplace(marketplaceDir, pluginSource, force);
+
+  const pluginDirFlag = `claude --plugin-dir ${pluginLink}`;
 
-  // Try `claude plugin install <path>` when the CLI is present.
+  // Without the Claude CLI we can only set up the files; the user must register manually.
+  let marketplaceAdd = { attempted: false, ok: false, skipped: skipEnable, error: "" };
   let enable = { attempted: false, ok: false, skipped: skipEnable, error: "" };
+
   if (!skipEnable) {
     if (!claudeBin) {
-      enable = {
-        attempted: false,
-        ok: false,
-        skipped: false,
-        error:
-          "Claude Code CLI was not found on PATH. Load the plugin manually with: claude --plugin-dir " +
-          pluginTarget,
-      };
+      const msg =
+        "Claude Code CLI was not found on PATH. Load the plugin manually with: " + pluginDirFlag;
+      marketplaceAdd = { attempted: false, ok: false, skipped: false, error: msg };
+      enable = { attempted: false, ok: false, skipped: false, error: msg };
     } else {
-      const result = spawnSync(claudeBin, ["plugin", "install", pluginTarget, "--scope", "user"], {
-        encoding: "utf8",
-        stdio: "pipe",
-      });
-      enable = {
+      // Register the local marketplace (idempotent — safe to re-run).
+      const addResult = spawnSync(
+        claudeBin,
+        ["plugin", "marketplace", "add", marketplaceDir, "--scope", "user"],
+        { encoding: "utf8", stdio: "pipe" },
+      );
+      marketplaceAdd = {
         attempted: true,
-        ok: result.status === 0,
+        ok: addResult.status === 0,
         skipped: false,
-        error: result.status === 0 ? "" : (result.stderr || result.stdout || "").trim(),
+        error: addResult.status === 0 ? "" : (addResult.stderr || addResult.stdout || "").trim(),
       };
+
+      if (marketplaceAdd.ok) {
+        // Install plugin from the now-registered local marketplace.
+        const installResult = spawnSync(
+          claudeBin,
+          ["plugin", "install", `agent-wallet@${CLAUDE_CODE_MARKETPLACE_NAME}`, "--scope", "user"],
+          { encoding: "utf8", stdio: "pipe" },
+        );
+        enable = {
+          attempted: true,
+          ok: installResult.status === 0,
+          skipped: false,
+          error:
+            installResult.status === 0
+              ? ""
+              : (installResult.stderr || installResult.stdout || "").trim(),
+        };
+      } else {
+        enable = {
+          attempted: false,
+          ok: false,
+          skipped: false,
+          error: "Skipped plugin install because marketplace registration failed.",
+        };
+      }
     }
   }
 
-  const pluginDirFlag = `claude --plugin-dir ${pluginTarget}`;
+  const ok = enable.skipped || enable.ok;
+  const pluginDirFlagFull = `claude --plugin-dir ${pluginSource}`;
   console.log(
     JSON.stringify(
       {
-        ok: enable.skipped || enable.ok,
+        ok,
         plugin_source: pluginSource,
-        plugin_target: pluginTarget,
+        marketplace_dir: marketplaceDir,
+        marketplace_add: marketplaceAdd,
         claude_code_install: enable,
-        manual_load: pluginDirFlag,
+        manual_load: pluginDirFlagFull,
         restart_required: true,
-        note: enable.ok
+        note: ok
           ? "Plugin registered. Restart Claude Code to activate."
-          : `If automatic registration failed, load the plugin with: ${pluginDirFlag}`,
+          : `If automatic registration failed, load the plugin with: ${pluginDirFlagFull}`,
       },
       null,
       2,

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

@@ -6,14 +6,19 @@ PLUGIN_ROOT=$(CDPATH= cd -- "$SCRIPT_DIR/.." && pwd)
 OPENCLAW_HOME=${OPENCLAW_HOME:-"$HOME/.openclaw"}
 PACKAGE_ROOT=${AGENT_WALLET_PACKAGE_ROOT:-${OPENCLAW_AGENT_WALLET_PACKAGE_ROOT:-"$OPENCLAW_HOME/agent-wallet-runtime/current/agent-wallet"}}
 
-# Resolve server.py: check sibling codex plugin (same npm package), then local copy
-CODEX_SERVER="$PLUGIN_ROOT/../../codex/plugins/agent-wallet/server.py"
+# Resolve server.py. When Claude Code copies this plugin into its cache, the
+# relative sibling paths below no longer resolve, so fall back to the codex
+# plugin copy inside the installed runtime package, which is always present.
 LOCAL_SERVER="$PLUGIN_ROOT/server.py"
+CODEX_SERVER="$PLUGIN_ROOT/../../codex/plugins/agent-wallet/server.py"
+RUNTIME_CODEX_DIR="$OPENCLAW_HOME/agent-wallet-runtime/current/codex/plugins/agent-wallet"
 
 if [ -f "$LOCAL_SERVER" ]; then
   SERVER_PY="$LOCAL_SERVER"
 elif [ -f "$CODEX_SERVER" ]; then
   SERVER_PY=$(CDPATH= cd -- "$PLUGIN_ROOT/../../codex/plugins/agent-wallet" && pwd)/server.py
+elif [ -f "$RUNTIME_CODEX_DIR/server.py" ]; then
+  SERVER_PY=$(CDPATH= cd -- "$RUNTIME_CODEX_DIR" && pwd)/server.py
 else
   printf '{"error":"agent-wallet server.py not found. Run: npx @agentlayer.tech/wallet install --yes"}\n' >&2
   exit 1

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

@@ -46,27 +46,17 @@ HOST_DEFAULT_CONFIG_KEYS = {
     "jupiterUltraBaseUrl",
     "jupiterPriceBaseUrl",
     "jupiterPortfolioBaseUrl",
-    "jupiterLendBaseUrl",
     "jupiterApiKey",
-    "houdiniBaseUrl",
-    "houdiniApiKey",
-    "houdiniApiSecret",
-    "houdiniUserIp",
-    "houdiniUserAgent",
-    "houdiniUserTimezone",
     "kaminoBaseUrl",
     "kaminoProgramId",
 }
 BACKENDS = ("solana_local", "wdk_btc_local", "wdk_evm_local")
 PREVIEW_CACHE_TTL_SECONDS = 15 * 60
-PRIVATE_SWAP_CACHE_TTL_SECONDS = 35 * 60
 PREVIEW_BOUND_SWAP_TOOLS = {
     "swap_solana_tokens",
-    "swap_solana_privately",
     "flash_trade_open_position",
     "flash_trade_close_position",
 }
-PRIVATE_SWAP_APPROVAL_TOOL_NAME = "swap_solana_privately"
 APPROVAL_PREVIEW_TOOL_ALIASES = {
     "x402_pay_request": "x402_preview_request",
 }
@@ -81,7 +71,6 @@ selected_solana_network: str | None = None
 selected_evm_network: str | None = None
 selected_btc_network: str | None = None
 approval_preview_cache: dict[str, dict[str, Any]] = {}
-private_swap_order_cache: dict[str, dict[str, Any]] = {}
 
 
 class WalletCliError(RuntimeError):
@@ -245,17 +234,10 @@ def _cache_preview_for_approval(user_id: str, tool_name: str, payload: dict[str,
     _prune_approval_preview_cache()
     approval_preview_cache[_approval_cache_key(user_id, cache_tool_name)] = {
         "digest": _preview_digest(data),
-        "expires_at": time.time()
-        + (
-            PRIVATE_SWAP_CACHE_TTL_SECONDS
-            if cache_tool_name == PRIVATE_SWAP_APPROVAL_TOOL_NAME
-            else PREVIEW_CACHE_TTL_SECONDS
-        ),
+        "expires_at": time.time() + PREVIEW_CACHE_TTL_SECONDS,
         "preview": data,
         "summary": summary,
     }
-    if cache_tool_name == PRIVATE_SWAP_APPROVAL_TOOL_NAME:
-        private_swap_order_cache.pop(_approval_cache_key(user_id, cache_tool_name), None)
 
 
 def _latest_cached_preview(user_id: str, tool_name: str) -> dict[str, Any] | None:
@@ -290,66 +272,6 @@ def _cached_preview_for_token(user_id: str, tool_name: str, token: str) -> dict[
     return preview if isinstance(preview, dict) else None
 
 
-def _cache_pending_private_swap_order(
-    user_id: str,
-    tool_name: str,
-    preview: dict[str, Any],
-    details: dict[str, Any],
-) -> None:
-    if tool_name != PRIVATE_SWAP_APPROVAL_TOOL_NAME:
-        return
-    houdini_id = str(details.get("houdini_id") or "").strip()
-    deposit_address = str(details.get("deposit_address") or "").strip()
-    if not houdini_id or not deposit_address:
-        return
-    private_swap_order_cache[_approval_cache_key(user_id, tool_name)] = {
-        "digest": _preview_digest(preview),
-        "expires_at": time.time() + PRIVATE_SWAP_CACHE_TTL_SECONDS,
-        "order": {
-            "multi_id": str(details.get("multi_id") or "").strip() or None,
-            "houdini_id": houdini_id,
-            "deposit_address": deposit_address,
-            "order": details.get("order") if isinstance(details.get("order"), dict) else {},
-        },
-    }
-
-
-def _latest_pending_private_swap_order(
-    user_id: str,
-    tool_name: str,
-    preview: dict[str, Any],
-) -> dict[str, Any] | None:
-    if tool_name != PRIVATE_SWAP_APPROVAL_TOOL_NAME:
-        return None
-    cached = private_swap_order_cache.get(_approval_cache_key(user_id, tool_name))
-    if not cached:
-        return None
-    if float(cached.get("expires_at") or 0) <= time.time():
-        private_swap_order_cache.pop(_approval_cache_key(user_id, tool_name), None)
-        return None
-    if cached.get("digest") != _preview_digest(preview):
-        return None
-    order = cached.get("order")
-    return order if isinstance(order, dict) else None
-
-
-def _clear_pending_private_swap_order(user_id: str, tool_name: str) -> None:
-    if tool_name == PRIVATE_SWAP_APPROVAL_TOOL_NAME:
-        private_swap_order_cache.pop(_approval_cache_key(user_id, tool_name), None)
-
-
-def _list_pending_private_swap_orders(user_id: str) -> list[dict[str, Any]]:
-    key = _approval_cache_key(user_id, PRIVATE_SWAP_APPROVAL_TOOL_NAME)
-    pending = private_swap_order_cache.get(key)
-    if not pending or float(pending.get("expires_at") or 0) <= time.time():
-        private_swap_order_cache.pop(key, None)
-        return []
-    order = pending.get("order")
-    if not isinstance(order, dict):
-        return []
-    return [{**order, "expires_at_ms": int(float(pending["expires_at"]) * 1000)}]
-
-
 def _normalize_wallet_backend(value: Any) -> str:
     normalized = str(value or "").strip().lower()
     aliases = {
@@ -651,8 +573,6 @@ def _issue_approval_token(
     ]
     if preview_payload.get("is_mainnet") is True:
         extra_args.append("--mainnet-confirmed")
-    if tool_name == PRIVATE_SWAP_APPROVAL_TOOL_NAME:
-        extra_args.extend(["--ttl-seconds", "1800"])
     payload = _call_wallet_cli("issue-approval", extra_args)
     token = str(payload.get("approval_token") or "").strip()
     if not token:
@@ -966,9 +886,6 @@ async def _handle_set_evm_network(params: dict[str, Any]) -> dict[str, Any]:
 
 
 async def _handle_wallet_tool(tool_name: str, params: dict[str, Any]) -> dict[str, Any]:
-    if tool_name == "list_pending_solana_private_swaps":
-        return {"orders": _list_pending_private_swap_orders(_user_id())}
-
     config = _base_config(params, tool_name=tool_name)
     backend = _normalize_wallet_backend(config.get("backend"))
     if backend == "wdk_evm_local" and params.get("network") is None and selected_evm_network:
@@ -976,24 +893,7 @@ async def _handle_wallet_tool(tool_name: str, params: dict[str, Any]) -> dict[st
         config["network"] = selected_evm_network
 
     effective_params = dict(params)
-    if tool_name != "continue_solana_private_swap":
-        _attach_approval_for_execute(tool_name, config, effective_params)
-    else:
-        cached = _latest_cached_preview(_user_id(), PRIVATE_SWAP_APPROVAL_TOOL_NAME)
-        if cached and isinstance(cached.get("preview"), dict):
-            effective_params["_approved_preview"] = cached["preview"]
-            effective_params["approval_token"] = _issue_approval_token(
-                PRIVATE_SWAP_APPROVAL_TOOL_NAME,
-                config,
-                cached["preview"],
-            )
-            pending = _latest_pending_private_swap_order(
-                _user_id(), PRIVATE_SWAP_APPROVAL_TOOL_NAME, cached["preview"]
-            )
-            if pending and effective_params.get("_resume_private_swap_order") is None:
-                effective_params["_resume_private_swap_order"] = pending
-        elif not effective_params.get("approval_token"):
-            raise RuntimeError(APPROVAL_CONTEXT_MISSING_MESSAGE)
+    _attach_approval_for_execute(tool_name, config, effective_params)
 
     try:
         payload = _invoke_tool(tool_name, effective_params, config)
@@ -1001,22 +901,6 @@ async def _handle_wallet_tool(tool_name: str, params: dict[str, Any]) -> dict[st
         raise _normalize_approval_context_error(exc) from exc
 
     _cache_preview_for_approval(_user_id(), tool_name, payload)
-    if tool_name == "swap_solana_privately" and payload.get("ok") is True:
-        data = payload.get("data")
-        approved_preview = effective_params.get("_approved_preview")
-        if (
-            isinstance(data, dict)
-            and data.get("execution_state") == "awaiting_deposit_funding"
-            and isinstance(approved_preview, dict)
-        ):
-            _cache_pending_private_swap_order(_user_id(), tool_name, approved_preview, data)
-        elif isinstance(data, dict):
-            _clear_pending_private_swap_order(_user_id(), tool_name)
-    if tool_name == "continue_solana_private_swap" and payload.get("ok") is True:
-        data = payload.get("data")
-        if isinstance(data, dict) and data.get("execution_state") == "funding_submitted":
-            _clear_pending_private_swap_order(_user_id(), PRIVATE_SWAP_APPROVAL_TOOL_NAME)
-
     if payload.get("ok") is False:
         raise RuntimeError(str(payload.get("error") or f"{tool_name} failed"))
     return payload.get("data", {})

package/hermes/plugins/agent_wallet/tools.py

@@ -15,7 +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"}
+PREVIEW_BOUND_SWAP_TOOLS = {"swap_solana_tokens"}
 
 
 def _json(data: dict[str, Any]) -> str:

package/package.json

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