@agentlayer.tech/wallet 0.1.27 → 0.1.30

package/agent-wallet/agent_wallet/bootstrap.py

@@ -5,7 +5,7 @@ from __future__ import annotations
 import json
 from pathlib import Path
 
-from agent_wallet.config import refuse_mainnet_wallet_recreation
+from agent_wallet.config import normalize_solana_network, refuse_mainnet_wallet_recreation
 from agent_wallet.file_ops import atomic_write_text
 from agent_wallet.wallet_layer.base import WalletBackendError
 from agent_wallet.wallet_layer.base58 import b58encode
@@ -79,11 +79,12 @@ def load_wallet_pin(path: Path) -> dict[str, str] | None:
 
 def write_wallet_pin(path: Path, *, address: str, network: str) -> dict[str, str]:
     """Persist the expected wallet address for later mismatch checks."""
+    normalized_network = normalize_solana_network(network)
     payload = {
         "kind": WALLET_ADDRESS_PIN_KIND,
         "version": WALLET_ADDRESS_PIN_VERSION,
         "address": address,
-        "network": network.strip().lower(),
+        "network": normalized_network,
         "wallet_file": path.name,
     }
     pin_path = resolve_wallet_pin_path(path)
@@ -97,7 +98,7 @@ def write_wallet_pin(path: Path, *, address: str, network: str) -> dict[str, str
 
 def ensure_wallet_pin(path: Path, *, address: str, network: str) -> dict[str, str]:
     """Ensure the wallet pin exists and matches the expected address."""
-    expected_network = network.strip().lower()
+    expected_network = normalize_solana_network(network)
     existing = load_wallet_pin(path)
     if existing is None:
         return write_wallet_pin(path, address=address, network=expected_network)
@@ -114,7 +115,7 @@ def ensure_wallet_pin(path: Path, *, address: str, network: str) -> dict[str, st
 
 def refuse_recreation_if_pinned(path: Path, *, network: str) -> None:
     """Refuse to recreate a wallet when a mainnet address is already pinned."""
-    expected_network = network.strip().lower()
+    expected_network = normalize_solana_network(network)
     if expected_network != "mainnet" or not refuse_mainnet_wallet_recreation():
         return
     existing = load_wallet_pin(path)
@@ -128,7 +129,11 @@ def refuse_recreation_if_pinned(path: Path, *, network: str) -> None:
 
 def ensure_solana_wallet_ready() -> dict[str, str] | None:
     """Ensure that a Solana wallet exists when auto-create is enabled."""
-    from agent_wallet.config import default_solana_wallet_path, resolve_solana_private_key, settings
+    from agent_wallet.config import (
+        default_solana_wallet_path,
+        resolve_solana_private_key,
+        settings,
+    )
 
     if settings.agent_wallet_backend.strip().lower() not in {"solana", "solana_local", "solana-local"}:
         return None
@@ -136,8 +141,13 @@ def ensure_solana_wallet_ready() -> dict[str, str] | None:
     if resolve_solana_private_key():
         return {"address": "", "path": ""}
 
+    normalized_network = normalize_solana_network(settings.solana_network)
     configured_path = settings.solana_agent_keypair_path.strip()
-    path = Path(configured_path).expanduser() if configured_path else default_solana_wallet_path(settings.solana_network)
+    path = (
+        Path(configured_path).expanduser()
+        if configured_path
+        else default_solana_wallet_path(normalized_network)
+    )
 
     if path.exists():
         return {"address": "", "path": str(path)}
@@ -145,9 +155,9 @@ def ensure_solana_wallet_ready() -> dict[str, str] | None:
     if not settings.solana_auto_create_wallet:
         return None
 
-    refuse_recreation_if_pinned(path, network=settings.solana_network)
+    refuse_recreation_if_pinned(path, network=normalized_network)
     created = create_solana_wallet_file(path)
-    write_wallet_pin(path, address=created["address"], network=settings.solana_network)
+    write_wallet_pin(path, address=created["address"], network=normalized_network)
     return created
 
 
@@ -155,22 +165,28 @@ def describe_bootstrap() -> dict[str, str | bool]:
     """Return the effective bootstrap configuration for installer/runtime usage."""
     from agent_wallet.config import (
         default_solana_wallet_path,
+        normalize_solana_network,
         resolve_solana_rpc_url,
         resolve_runtime_solana_rpc_urls,
         settings,
     )
 
+    normalized_network = normalize_solana_network(settings.solana_network)
     configured_path = settings.solana_agent_keypair_path.strip()
-    path = Path(configured_path).expanduser() if configured_path else default_solana_wallet_path(settings.solana_network)
+    path = (
+        Path(configured_path).expanduser()
+        if configured_path
+        else default_solana_wallet_path(normalized_network)
+    )
     rpc_urls = resolve_runtime_solana_rpc_urls(
-        settings.solana_network,
+        normalized_network,
         settings.solana_rpc_url,
         settings.solana_rpc_urls,
     )
     return {
         "backend": settings.agent_wallet_backend,
-        "network": settings.solana_network,
-        "rpc_url": rpc_urls[0] if rpc_urls else resolve_solana_rpc_url(settings.solana_network, ""),
+        "network": normalized_network,
+        "rpc_url": rpc_urls[0] if rpc_urls else resolve_solana_rpc_url(normalized_network, ""),
         "rpc_urls": rpc_urls,
         "auto_create_wallet": settings.solana_auto_create_wallet,
         "keypair_path": str(path),

package/agent-wallet/agent_wallet/btc_user_wallets.py

@@ -6,19 +6,14 @@ import json
 from pathlib import Path
 from typing import Any
 
-from agent_wallet.config import resolve_openclaw_home, settings
+from agent_wallet.config import normalize_btc_network, resolve_openclaw_home, settings
 from agent_wallet.providers.wdk_btc_local import WdkBtcLocalClient
 from agent_wallet.user_wallets import normalize_user_id
 from agent_wallet.wallet_layer.base import WalletBackendError
 
 
 def _normalize_btc_network(value: str | None) -> str:
-    network = str(value or "").strip().lower()
-    aliases = {"mainnet": "bitcoin"}
-    network = aliases.get(network, network)
-    if network not in {"bitcoin", "testnet", "regtest"}:
-        return "bitcoin"
-    return network
+    return normalize_btc_network(value)
 
 
 def _resolve_service_url(service_url: str | None = None) -> str:

package/agent-wallet/agent_wallet/config.py

@@ -82,6 +82,79 @@ class Settings(BaseSettings):
 settings = Settings()
 
 
+def normalize_solana_network(network: str | None) -> str:
+    """Canonicalize supported Solana network names and reject test clusters."""
+    normalized = str(network or "").strip().lower() or "mainnet"
+    aliases = {
+        "mainnet-beta": "mainnet",
+    }
+    normalized = aliases.get(normalized, normalized)
+    if normalized in {"devnet", "testnet"}:
+        from agent_wallet.wallet_layer.base import WalletBackendError
+
+        raise WalletBackendError(
+            "Solana devnet/testnet are no longer supported by agent-wallet. "
+            "Use mainnet or remove the Solana network override."
+        )
+    if normalized != "mainnet":
+        from agent_wallet.wallet_layer.base import WalletBackendError
+
+        raise WalletBackendError(
+            f"Unsupported Solana network: {normalized}. Only mainnet is supported."
+        )
+    return "mainnet"
+
+
+def normalize_evm_network(network: str | None) -> str:
+    """Canonicalize supported EVM network names and reject testnets."""
+    normalized = str(network or "").strip().lower() or "ethereum"
+    aliases = {
+        "mainnet": "ethereum",
+        "eth": "ethereum",
+        "eth-mainnet": "ethereum",
+        "base-mainnet": "base",
+    }
+    normalized = aliases.get(normalized, normalized)
+    if normalized in {"sepolia", "base-sepolia", "base_sepolia"}:
+        from agent_wallet.wallet_layer.base import WalletBackendError
+
+        raise WalletBackendError(
+            "EVM testnets are no longer supported by agent-wallet. Use ethereum or base."
+        )
+    if normalized not in {"ethereum", "base"}:
+        from agent_wallet.wallet_layer.base import WalletBackendError
+
+        raise WalletBackendError(
+            f"Unsupported EVM network: {normalized}. Use ethereum or base."
+        )
+    return normalized
+
+
+def normalize_btc_network(network: str | None) -> str:
+    """Canonicalize supported BTC network names and reject non-mainnet chains."""
+    normalized = str(network or "").strip().lower() or "bitcoin"
+    aliases = {
+        "mainnet": "bitcoin",
+        "btc": "bitcoin",
+        "bitcoin-mainnet": "bitcoin",
+        "bitcoin_mainnet": "bitcoin",
+    }
+    normalized = aliases.get(normalized, normalized)
+    if normalized in {"testnet", "regtest"}:
+        from agent_wallet.wallet_layer.base import WalletBackendError
+
+        raise WalletBackendError(
+            "Bitcoin testnet/regtest are no longer supported by agent-wallet. Use bitcoin."
+        )
+    if normalized != "bitcoin":
+        from agent_wallet.wallet_layer.base import WalletBackendError
+
+        raise WalletBackendError(
+            f"Unsupported Bitcoin network: {normalized}. Only bitcoin is supported."
+        )
+    return "bitcoin"
+
+
 def _normalize_provider_mode(value: str | None) -> str:
     mode = (value or "").strip().lower()
     if not mode:
@@ -129,20 +202,20 @@ def resolve_openclaw_home() -> Path:
 
 def default_solana_wallet_path(network: str) -> Path:
     """Return the default keypair path for a Solana wallet."""
-    return resolve_openclaw_home() / "wallets" / f"solana-{network}-agent.json"
+    normalized_network = normalize_solana_network(network)
+    return resolve_openclaw_home() / "wallets" / f"solana-{normalized_network}-agent.json"
 
 
 def resolve_solana_rpc_url(network: str, configured: str) -> str:
     """Resolve the effective Solana RPC URL from network + optional override."""
+    normalized_network = normalize_solana_network(network)
     if configured.strip():
         return configured.strip()
 
     mapping = {
         "mainnet": "https://api.mainnet-beta.solana.com",
-        "devnet": "https://api.devnet.solana.com",
-        "testnet": "https://api.testnet.solana.com",
     }
-    return mapping.get(network.strip().lower(), mapping["mainnet"])
+    return mapping.get(normalized_network, mapping["mainnet"])
 
 
 def resolve_solana_rpc_urls(
@@ -151,17 +224,18 @@ def resolve_solana_rpc_urls(
     configured_list: str = "",
 ) -> list[str]:
     """Resolve the ordered list of Solana RPC URLs to try."""
+    normalized_network = normalize_solana_network(network)
     candidates: list[str] = []
     for raw in (configured_list or "").split(","):
         value = raw.strip()
         if value and value not in candidates:
             candidates.append(value)
 
-    primary = resolve_solana_rpc_url(network, configured)
+    primary = resolve_solana_rpc_url(normalized_network, configured)
     if primary and primary not in candidates:
         candidates.insert(0, primary)
 
-    official = resolve_solana_rpc_url(network, "")
+    official = resolve_solana_rpc_url(normalized_network, "")
     if official and official not in candidates:
         candidates.append(official)
 
@@ -169,7 +243,8 @@ def resolve_solana_rpc_urls(
 
 
 def _build_provider_gateway_rpc_url(base_url: str, provider: str, network: str) -> str:
-    return f"gateway::{provider}::{network.strip().lower()}::{base_url.rstrip('/')}/v1/rpc"
+    normalized_network = normalize_solana_network(network)
+    return f"gateway::{provider}::{normalized_network}::{base_url.rstrip('/')}/v1/rpc"
 
 
 def resolve_runtime_solana_rpc_config(
@@ -185,6 +260,7 @@ def resolve_runtime_solana_rpc_config(
     3. shared proxy gateway
     4. public official fallback
     """
+    normalized_network = normalize_solana_network(network)
     mode = _normalize_provider_mode(
         os.getenv("SOLANA_RPC_PROVIDER_MODE", settings.solana_rpc_provider_mode)
     )
@@ -200,10 +276,10 @@ def resolve_runtime_solana_rpc_config(
             "mode": "user_direct",
             "provider": "custom",
             "transport": "direct",
-            "rpc_urls": resolve_solana_rpc_urls(network, env_primary, env_list),
+            "rpc_urls": resolve_solana_rpc_urls(normalized_network, env_primary, env_list),
         }
     if env_list:
-        official = resolve_solana_rpc_url(network, "")
+        official = resolve_solana_rpc_url(normalized_network, "")
         candidates = [item.strip() for item in env_list.split(",") if item.strip()]
         if official and official not in candidates:
             candidates.append(official)
@@ -218,16 +294,15 @@ def resolve_runtime_solana_rpc_config(
     if alchemy_key:
         alchemy_base_by_network = {
             "mainnet": "https://solana-mainnet.g.alchemy.com/v2",
-            "devnet": "https://solana-devnet.g.alchemy.com/v2",
         }
-        alchemy_base = alchemy_base_by_network.get(network.strip().lower())
+        alchemy_base = alchemy_base_by_network.get(normalized_network)
         if alchemy_base:
             return {
                 "mode": "user_direct",
                 "provider": "alchemy",
                 "transport": "direct",
                 "rpc_urls": resolve_solana_rpc_urls(
-                    network,
+                    normalized_network,
                     f"{alchemy_base}/{alchemy_key}",
                     "",
                 ),
@@ -237,35 +312,40 @@ def resolve_runtime_solana_rpc_config(
     if helius_key:
         helius_base_by_network = {
             "mainnet": "https://mainnet.helius-rpc.com/",
-            "devnet": "https://devnet.helius-rpc.com/",
         }
-        helius_base = helius_base_by_network.get(network.strip().lower())
+        helius_base = helius_base_by_network.get(normalized_network)
         if helius_base:
             return {
                 "mode": "user_direct",
                 "provider": "helius",
                 "transport": "direct",
                 "rpc_urls": resolve_solana_rpc_urls(
-                    network,
+                    normalized_network,
                     f"{helius_base}?api-key={helius_key}",
                     "",
                 ),
             }
 
-    if network.strip().lower() == "mainnet" and (mode == "shared_proxy" or (mode == "auto" and gateway_url)):
+    if normalized_network == "mainnet" and (mode == "shared_proxy" or (mode == "auto" and gateway_url)):
         if gateway_url:
             return {
                 "mode": "shared_proxy",
                 "provider": gateway_provider,
                 "transport": "proxy",
-                "rpc_urls": [_build_provider_gateway_rpc_url(gateway_url, gateway_provider, network)],
+                "rpc_urls": [
+                    _build_provider_gateway_rpc_url(
+                        gateway_url,
+                        gateway_provider,
+                        normalized_network,
+                    )
+                ],
             }
 
     return {
         "mode": "public_fallback",
         "provider": "official",
         "transport": "direct",
-        "rpc_urls": resolve_solana_rpc_urls(network, configured, configured_list),
+        "rpc_urls": resolve_solana_rpc_urls(normalized_network, configured, configured_list),
     }
 
 
@@ -289,10 +369,7 @@ def resolve_runtime_solana_swap_config(network: str) -> dict[str, str]:
     requested = _normalize_swap_provider(
         os.getenv("SOLANA_SWAP_PROVIDER", settings.solana_swap_provider)
     )
-    normalized_network = network.strip().lower()
-
-    if normalized_network != "mainnet":
-        return {"provider": "jupiter", "transport": "direct"}
+    normalize_solana_network(network)
 
     if requested == "jupiter":
         return {"provider": "jupiter", "transport": "direct"}

package/agent-wallet/agent_wallet/evm_user_wallets.py

@@ -14,6 +14,7 @@ from urllib.parse import urlparse
 from urllib.request import urlopen
 
 from agent_wallet.config import (
+    normalize_evm_network,
     resolve_boot_key,
     resolve_evm_wallet_password,
     resolve_openclaw_home,
@@ -27,18 +28,7 @@ LOCAL_WDK_EVM_HOSTS = {"127.0.0.1", "localhost", "::1"}
 
 
 def _normalize_evm_network(value: str | None) -> 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
+    return normalize_evm_network(value)
 
 
 def _resolve_service_url(service_url: str | None = None) -> str:
@@ -52,8 +42,6 @@ def _paired_network(network: str) -> str | None:
     mapping = {
         "ethereum": "base",
         "base": "ethereum",
-        "sepolia": "base-sepolia",
-        "base-sepolia": "sepolia",
     }
     return mapping.get(_normalize_evm_network(network))
 

package/agent-wallet/agent_wallet/openclaw_adapter.py

@@ -101,9 +101,10 @@ class OpenClawWalletAdapter:
             "eth": "ethereum",
             "eth-mainnet": "ethereum",
             "base-mainnet": "base",
-            "base_sepolia": "base-sepolia",
         }
         network = aliases.get(network, network)
+        if network in {"sepolia", "base-sepolia", "base_sepolia"}:
+            raise WalletBackendError("EVM testnets are no longer supported. Use ethereum or base.")
         if network not in {"ethereum", "base"}:
             raise WalletBackendError("EVM network must be 'ethereum' or 'base'.")
         return network
@@ -245,8 +246,9 @@ class OpenClawWalletAdapter:
             AgentToolSpec(
                 name="x402_pay_request",
                 description=(
-                    "Prepare or execute an x402 paid request using the active wallet backend. "
-                    "This milestone executes the Solana exact buyer flow and keeps EVM as prepare-only."
+                    "Pay for and call an x402 endpoint using the active wallet backend. "
+                    "The tool probes the endpoint, validates compatibility, signs the payment, "
+                    "and returns the service response in one call."
                 ),
                 input_schema={
                     "type": "object",
@@ -257,26 +259,13 @@ class OpenClawWalletAdapter:
                         "query": {"type": "object", "additionalProperties": True},
                         "json_body": {},
                         "text_body": {"type": "string"},
-                        "mode": {
-                            "type": "string",
-                            "enum": ["prepare", "execute"],
-                            "description": "prepare validates the payment plan; execute sends the paid retry.",
-                        },
                         "purpose": {"type": "string"},
-                        "user_intent": {
-                            "type": "boolean",
-                            "description": "Must be true for prepare mode.",
-                        },
-                        "approval_token": {
-                            "type": "string",
-                            "description": "Required for execute mode and must be issued against the exact x402 payment summary.",
-                        },
                     },
-                    "required": ["url", "mode", "purpose"],
+                    "required": ["url", "purpose"],
                     "additionalProperties": False,
                 },
                 read_only=False,
-                requires_explicit_user_intent=True,
+                requires_explicit_user_intent=False,
                 risk_level="high",
             ),
         ]
@@ -872,6 +861,42 @@ class OpenClawWalletAdapter:
             )
         return annotated
 
+    def _annotate_x402_payload(
+        self,
+        payload: dict[str, Any],
+        *,
+        mode: str,
+    ) -> dict[str, Any]:
+        if not payload.get("payment_required"):
+            return dict(payload)
+        annotated = self._annotate_sensitive_payload(
+            payload,
+            action_label="x402 paid request",
+            mode=mode,
+        )
+        summary = dict(annotated.get("confirmation_summary") or {})
+        if summary:
+            annotated["payment_summary"] = summary
+        requirements = dict(annotated.get("confirmation_requirements") or {})
+        requirements["prepare_requires_user_intent"] = False
+        requirements["execute_requires_approval_token"] = False
+        requirements["execute_requires_mainnet_confirmed_in_token"] = False
+        annotated.pop("approval_hint", None)
+        if mode == "preview":
+            annotated.pop("confirmation_summary", None)
+            annotated.pop("confirmation_requirements", None)
+            if annotated.get("is_mainnet"):
+                annotated["preview_note"] = (
+                    "This is a paid mainnet endpoint preview only. Review the service URL, network, asset, amount, and payment destination before calling x402_pay_request."
+                )
+            return annotated
+        annotated["confirmation_requirements"] = requirements
+        if annotated.get("is_mainnet"):
+            annotated["mainnet_warning"] = (
+                "Mainnet x402 payment. Confirm the service URL, network, asset, amount, and payment destination before paying."
+            )
+        return annotated
+
     def list_tools(self) -> list[AgentToolSpec]:
         """Return wallet tools suitable for agent registration."""
         capabilities = self.backend.get_capabilities()
@@ -2290,6 +2315,25 @@ class OpenClawWalletAdapter:
                 read_only=True,
                 risk_level="low",
             ),
+            AgentToolSpec(
+                name="get_kamino_open_positions",
+                description=(
+                    "Get all open Kamino lending positions for a Solana wallet on mainnet, "
+                    "aggregated across markets with loan details, reserve APYs, and rewards."
+                ),
+                input_schema={
+                    "type": "object",
+                    "properties": {
+                        "user": {
+                            "type": "string",
+                            "description": "Optional Solana wallet address override. If omitted, use the configured wallet.",
+                        },
+                    },
+                    "additionalProperties": False,
+                },
+                read_only=True,
+                risk_level="low",
+            ),
         ]
 
         if capabilities.can_sign_message:
@@ -3197,30 +3241,6 @@ class OpenClawWalletAdapter:
                 )
             )
 
-            tools.append(
-                AgentToolSpec(
-                    name="request_devnet_airdrop",
-                    description=(
-                        "Request SOL from the Solana faucet on devnet or testnet. "
-                        "Only available outside mainnet."
-                    ),
-                    input_schema={
-                        "type": "object",
-                        "properties": {
-                            "amount": {
-                                "type": "number",
-                                "description": "Amount of SOL to request from faucet.",
-                            }
-                        },
-                        "required": ["amount"],
-                        "additionalProperties": False,
-                    },
-                    read_only=False,
-                    requires_explicit_user_intent=True,
-                    risk_level="low",
-                )
-            )
-
         tools.extend(self._x402_tool_specs())
         return [tool for tool in tools if tool.name not in TEMPORARILY_DISABLED_TOOLS]
 
@@ -3309,14 +3329,7 @@ class OpenClawWalletAdapter:
                     text_body=text_body,
                 )
                 if data.get("payment_required"):
-                    data = self._annotate_sensitive_payload(
-                        data,
-                        action_label="x402 paid request",
-                        mode="preview",
-                    )
-                    approval_hint = dict(data.get("approval_hint") or {})
-                    approval_hint["tool_name"] = "x402_pay_request"
-                    data["approval_hint"] = approval_hint
+                    data = self._annotate_x402_payload(data, mode="preview")
                 return AgentToolResult(tool=tool_name, ok=True, data=data)
 
             if tool_name == "x402_pay_request":
@@ -3326,10 +3339,7 @@ class OpenClawWalletAdapter:
                 query = args.get("query")
                 json_body = args.get("json_body")
                 text_body = args.get("text_body")
-                mode = str(args.get("mode") or "").strip().lower()
                 purpose = args.get("purpose")
-                user_intent = args.get("user_intent")
-                approval_token = args.get("approval_token")
                 if not isinstance(url, str) or not url.strip():
                     raise WalletBackendError("url is required.")
                 if method is not None and not isinstance(method, str):
@@ -3340,51 +3350,9 @@ class OpenClawWalletAdapter:
                     raise WalletBackendError("query must be an object when provided.")
                 if text_body is not None and not isinstance(text_body, str):
                     raise WalletBackendError("text_body must be a string when provided.")
-                if mode not in {"prepare", "execute"}:
-                    raise WalletBackendError("mode must be 'prepare' or 'execute'.")
                 if not isinstance(purpose, str) or not purpose.strip():
                     raise WalletBackendError("purpose is required.")
-                if mode == "prepare":
-                    self._require_prepare_intent(user_intent)
-                    data = await x402.prepare_request(
-                        backend=active_backend,
-                        url=url.strip(),
-                        method=method,
-                        headers=headers,
-                        query=query,
-                        json_body=json_body,
-                        text_body=text_body,
-                    )
-                    data["purpose"] = purpose.strip()
-                    data = self._annotate_sensitive_payload(
-                        data,
-                        action_label="x402 paid request",
-                        mode="prepare",
-                    )
-                    return AgentToolResult(tool=tool_name, ok=True, data=data)
-                preview = await x402.prepare_request(
-                    backend=active_backend,
-                    url=url.strip(),
-                    method=method,
-                    headers=headers,
-                    query=query,
-                    json_body=json_body,
-                    text_body=text_body,
-                )
-                preview["purpose"] = purpose.strip()
-                preview = self._annotate_sensitive_payload(
-                    preview,
-                    action_label="x402 paid request",
-                    mode="execute",
-                )
-                self._require_execute_approval(
-                    approval_token=approval_token,
-                    tool_name=tool_name,
-                    summary=preview["confirmation_summary"],
-                    action_label="x402 paid request",
-                    backend=active_backend,
-                )
-                data = await x402.execute_request(
+                data = await x402.pay_and_fetch(
                     backend=active_backend,
                     url=url.strip(),
                     method=method,
@@ -3394,11 +3362,7 @@ class OpenClawWalletAdapter:
                     text_body=text_body,
                 )
                 data["purpose"] = purpose.strip()
-                data = self._annotate_sensitive_payload(
-                    data,
-                    action_label="x402 paid request",
-                    mode="execute",
-                )
+                data = self._annotate_x402_payload(data, mode="execute")
                 return AgentToolResult(tool=tool_name, ok=True, data=data)
 
             if tool_name == "get_wallet_capabilities":
@@ -4669,6 +4633,13 @@ class OpenClawWalletAdapter:
                 data = await self.backend.get_kamino_lend_user_rewards(user=user)
                 return AgentToolResult(tool=tool_name, ok=True, data=data)
 
+            if tool_name == "get_kamino_open_positions":
+                user = args.get("user")
+                if user is not None and not isinstance(user, str):
+                    raise WalletBackendError("user must be a string when provided.")
+                data = await self.backend.get_kamino_open_positions(user=user)
+                return AgentToolResult(tool=tool_name, ok=True, data=data)
+
             if tool_name == "sign_wallet_message":
                 user_confirmed = args.get("user_confirmed")
                 if user_confirmed is not True:
@@ -5231,13 +5202,6 @@ class OpenClawWalletAdapter:
                     ),
                 )
 
-            if tool_name == "request_devnet_airdrop":
-                amount = args.get("amount")
-                if not isinstance(amount, (int, float)) or amount <= 0:
-                    raise WalletBackendError("amount must be a positive number.")
-                result = await self.backend.request_testnet_airdrop(float(amount))
-                return AgentToolResult(tool=tool_name, ok=True, data=result)
-
             if tool_name == "transfer_spl_token":
                 recipient = args.get("recipient")
                 mint = args.get("mint")