@agentlayer.tech/wallet 0.1.17 → 0.1.19

package/agent-wallet/agent_wallet/openclaw_adapter.py

@@ -7,7 +7,9 @@ import json
 from typing import Any
 
 from agent_wallet.approval import inspect_approval_token, verify_approval_token
+from agent_wallet.exceptions import ProviderError
 from agent_wallet.models import AgentToolResult, AgentToolSpec
+from agent_wallet.providers import x402
 from agent_wallet.wallet_layer.base import AgentWalletBackend, WalletBackendError
 
 
@@ -75,7 +77,9 @@ class OpenClawWalletAdapter:
         if chain == "bitcoin":
             return normalized == "bitcoin"
         if chain == "evm":
-            return normalized in {"ethereum", "base"}
+            return normalized in {"ethereum", "base", "eip155:1", "eip155:8453"}
+        if chain == "solana":
+            return normalized in {"mainnet", "solana:5eykt4usfv8p8njdtrepy1vzkqzkvdp"}
         return normalized == "mainnet"
 
     def _is_mainnet(self) -> bool:
@@ -168,6 +172,115 @@ class OpenClawWalletAdapter:
                 "Prepare mode requires explicit user intent confirmation."
             )
 
+    def _x402_tool_specs(self) -> list[AgentToolSpec]:
+        return [
+            AgentToolSpec(
+                name="x402_search_services",
+                description=(
+                    "Search x402-paid services through CDP Bazaar or Agentic Market. "
+                    "This is read-only discovery and does not spend funds."
+                ),
+                input_schema={
+                    "type": "object",
+                    "properties": {
+                        "query": {"type": "string"},
+                        "discovery_provider": {
+                            "type": "string",
+                            "enum": ["auto", "cdp_bazaar", "agentic_market"],
+                        },
+                        "network": {"type": "string"},
+                        "asset": {"type": "string"},
+                        "scheme": {"type": "string"},
+                        "max_usd_price": {"type": "string"},
+                        "limit": {"type": "integer"},
+                    },
+                    "additionalProperties": False,
+                },
+                read_only=True,
+                risk_level="low",
+            ),
+            AgentToolSpec(
+                name="x402_get_service_details",
+                description=(
+                    "Resolve one x402 service or resource into a normalized details payload. "
+                    "Use a resource URL for CDP Bazaar or a domain/service id for Agentic Market."
+                ),
+                input_schema={
+                    "type": "object",
+                    "properties": {
+                        "reference": {"type": "string"},
+                        "discovery_provider": {
+                            "type": "string",
+                            "enum": ["auto", "cdp_bazaar", "agentic_market"],
+                        },
+                    },
+                    "required": ["reference"],
+                    "additionalProperties": False,
+                },
+                read_only=True,
+                risk_level="low",
+            ),
+            AgentToolSpec(
+                name="x402_preview_request",
+                description=(
+                    "Make an unpaid HTTP request to an x402 endpoint, detect HTTP 402, parse "
+                    "PAYMENT-REQUIRED, and summarize the payment options. This does not pay or execute."
+                ),
+                input_schema={
+                    "type": "object",
+                    "properties": {
+                        "url": {"type": "string"},
+                        "method": {"type": "string"},
+                        "headers": {"type": "object", "additionalProperties": {"type": "string"}},
+                        "query": {"type": "object", "additionalProperties": True},
+                        "json_body": {},
+                        "text_body": {"type": "string"},
+                    },
+                    "required": ["url"],
+                    "additionalProperties": False,
+                },
+                read_only=True,
+                risk_level="low",
+            ),
+            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."
+                ),
+                input_schema={
+                    "type": "object",
+                    "properties": {
+                        "url": {"type": "string"},
+                        "method": {"type": "string"},
+                        "headers": {"type": "object", "additionalProperties": {"type": "string"}},
+                        "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"],
+                    "additionalProperties": False,
+                },
+                read_only=False,
+                requires_explicit_user_intent=True,
+                risk_level="high",
+            ),
+        ]
+
     def _require_execute_approval(
         self,
         *,
@@ -550,6 +663,23 @@ class OpenClawWalletAdapter:
                 "btc_transfer_fingerprint": btc_fingerprint,
             }
 
+        if asset_type == "x402-request":
+            return {
+                "operation": action_label,
+                "network": str(payload.get("network") or getattr(self.backend, "network", "unknown")),
+                "wallet": payload.get("wallet"),
+                "request_url": payload.get("request_url"),
+                "method": payload.get("method"),
+                "request_fingerprint": payload.get("request_fingerprint"),
+                "body_hash": payload.get("body_hash"),
+                "x402_network": payload.get("x402_network"),
+                "x402_scheme": payload.get("x402_scheme"),
+                "x402_asset": payload.get("x402_asset"),
+                "x402_amount": payload.get("x402_amount"),
+                "x402_amount_display": payload.get("x402_amount_display"),
+                "x402_pay_to": payload.get("x402_pay_to"),
+            }
+
         if asset_type == "evm-native-transfer":
             evm_binding = {
                 "recipient": payload.get("recipient"),
@@ -3038,6 +3168,7 @@ class OpenClawWalletAdapter:
                 )
             )
 
+        tools.extend(self._x402_tool_specs())
         return [tool for tool in tools if tool.name not in TEMPORARILY_DISABLED_TOOLS]
 
     def get_runtime_instructions(self) -> str:
@@ -3054,6 +3185,169 @@ class OpenClawWalletAdapter:
                     f"{tool_name} is temporarily disabled. The implementation remains in the repo but this tool is currently turned off."
                 )
 
+            if tool_name == "x402_search_services":
+                query = args.get("query")
+                discovery_provider = args.get("discovery_provider", "auto")
+                network = args.get("network")
+                asset = args.get("asset")
+                scheme = args.get("scheme")
+                max_usd_price = args.get("max_usd_price")
+                limit = args.get("limit", 10)
+                for field_name, value in (
+                    ("query", query),
+                    ("discovery_provider", discovery_provider),
+                    ("network", network),
+                    ("asset", asset),
+                    ("scheme", scheme),
+                    ("max_usd_price", max_usd_price),
+                ):
+                    if value is not None and not isinstance(value, str):
+                        raise WalletBackendError(f"{field_name} must be a string when provided.")
+                if not isinstance(limit, int) or limit <= 0:
+                    raise WalletBackendError("limit must be a positive integer.")
+                data = await x402.search_services(
+                    query=query,
+                    discovery_provider=discovery_provider,
+                    network=network,
+                    asset=asset,
+                    scheme=scheme,
+                    max_usd_price=max_usd_price,
+                    limit=limit,
+                )
+                return AgentToolResult(tool=tool_name, ok=True, data=data)
+
+            if tool_name == "x402_get_service_details":
+                reference = args.get("reference")
+                discovery_provider = args.get("discovery_provider", "auto")
+                if not isinstance(reference, str) or not reference.strip():
+                    raise WalletBackendError("reference is required.")
+                if discovery_provider is not None and not isinstance(discovery_provider, str):
+                    raise WalletBackendError("discovery_provider must be a string when provided.")
+                data = await x402.get_service_details(
+                    reference=reference.strip(),
+                    discovery_provider=discovery_provider,
+                )
+                return AgentToolResult(tool=tool_name, ok=True, data=data)
+
+            if tool_name == "x402_preview_request":
+                url = args.get("url")
+                method = args.get("method", "GET")
+                headers = args.get("headers")
+                query = args.get("query")
+                json_body = args.get("json_body")
+                text_body = args.get("text_body")
+                if not isinstance(url, str) or not url.strip():
+                    raise WalletBackendError("url is required.")
+                if method is not None and not isinstance(method, str):
+                    raise WalletBackendError("method must be a string when provided.")
+                if headers is not None and not isinstance(headers, dict):
+                    raise WalletBackendError("headers must be an object when provided.")
+                if query is not None and not isinstance(query, dict):
+                    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.")
+                data = await x402.preview_request(
+                    backend=active_backend,
+                    url=url.strip(),
+                    method=method,
+                    headers=headers,
+                    query=query,
+                    json_body=json_body,
+                    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
+                return AgentToolResult(tool=tool_name, ok=True, data=data)
+
+            if tool_name == "x402_pay_request":
+                url = args.get("url")
+                method = args.get("method", "GET")
+                headers = args.get("headers")
+                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):
+                    raise WalletBackendError("method must be a string when provided.")
+                if headers is not None and not isinstance(headers, dict):
+                    raise WalletBackendError("headers must be an object when provided.")
+                if query is not None and not isinstance(query, dict):
+                    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(
+                    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="execute",
+                )
+                return AgentToolResult(tool=tool_name, ok=True, data=data)
+
             if tool_name == "get_wallet_capabilities":
                 data = active_backend.get_capabilities().to_dict()
                 data["network"] = str(getattr(active_backend, "network", "unknown"))
@@ -6053,4 +6347,12 @@ class OpenClawWalletAdapter:
                     error_code=exc.code,
                     error_details=exc.details,
                 )
+            if isinstance(exc, ProviderError):
+                return AgentToolResult(
+                    tool=tool_name,
+                    ok=False,
+                    error=str(exc),
+                    error_code=exc.provider,
+                    error_details=exc.details,
+                )
             return AgentToolResult(tool=tool_name, ok=False, error=str(exc))

package/agent-wallet/agent_wallet/openclaw_runtime.py

@@ -8,7 +8,7 @@ from typing import Any
 from agent_wallet.approval import issue_approval_token
 from agent_wallet.btc_user_wallets import get_user_btc_wallet_binding
 from agent_wallet.config import settings
-from agent_wallet.evm_user_wallets import ensure_user_evm_wallet_binding, get_user_evm_wallet_binding
+from agent_wallet.evm_user_wallets import ensure_user_evm_wallet_ready
 from agent_wallet.models import OpenClawWalletSessionMetadata
 from agent_wallet.openclaw_adapter import OpenClawWalletAdapter
 from agent_wallet.plugin_bundle import build_openclaw_plugin_bundle
@@ -173,38 +173,17 @@ def onboard_openclaw_user_wallet(
             "base_sepolia": "base-sepolia",
         }
         effective_network = aliases.get(requested_network, requested_network)
-        binding: dict[str, Any] | None = None
         wallet_id = str(wdk_evm_wallet_id or settings.wdk_evm_wallet_id).strip()
         if not service_url:
             raise WalletBackendError("wdk_evm_service_url is required for backend=wdk_evm_local.")
-        if wallet_id:
-            try:
-                binding = get_user_evm_wallet_binding(user_id, network=effective_network)
-            except WalletBackendError:
-                binding = ensure_user_evm_wallet_binding(
-                    user_id,
-                    network=effective_network,
-                    service_url=service_url,
-                    wallet_id=wallet_id,
-                    account_index=account_index,
-                )
-            else:
-                if str(binding.get("wallet_id") or "").strip() != wallet_id:
-                    binding = ensure_user_evm_wallet_binding(
-                        user_id,
-                        network=effective_network,
-                        service_url=service_url,
-                        wallet_id=wallet_id,
-                        account_index=account_index,
-                    )
-        else:
-            binding = ensure_user_evm_wallet_binding(
-                user_id,
-                network=effective_network,
-                service_url=service_url,
-                account_index=account_index,
-            )
-            wallet_id = str(binding.get("wallet_id") or "").strip()
+        binding = ensure_user_evm_wallet_ready(
+            user_id,
+            network=effective_network,
+            service_url=service_url,
+            wallet_id=wallet_id or None,
+            account_index=account_index,
+        )
+        wallet_id = str(binding.get("wallet_id") or wallet_id).strip()
         if not wallet_id:
             raise WalletBackendError(
                 "wdk_evm_wallet_id is required for backend=wdk_evm_local, or create a bound user EVM wallet first."
@@ -212,17 +191,7 @@ def onboard_openclaw_user_wallet(
 
         client = WdkEvmLocalClient(service_url)
         wallet_meta = client.post_sync("/v1/evm/wallets/get", {"walletId": wallet_id})
-        resolved_address = str((binding or {}).get("address") or "").strip()
-        if not resolved_address:
-            address_payload = client.post_sync(
-                "/v1/evm/address/resolve",
-                {
-                    "walletId": wallet_id,
-                    "accountIndex": account_index,
-                    "network": effective_network,
-                },
-            )
-            resolved_address = str(address_payload.get("address") or "").strip()
+        resolved_address = str(binding.get("address") or "").strip()
         backend = WdkEvmLocalWalletBackend(
             service_url=service_url,
             wallet_id=wallet_id,

package/agent-wallet/agent_wallet/providers/wdk_evm_local.py

@@ -102,6 +102,35 @@ def _unwrap_payload(response: httpx.Response) -> dict[str, Any]:
     return data
 
 
+def _unwrap_list_payload(response: httpx.Response) -> list[dict[str, Any]]:
+    try:
+        payload = response.json()
+    except Exception as exc:  # pragma: no cover - defensive
+        raise WalletBackendError(
+            f"wdk-evm-wallet returned a non-JSON response ({response.status_code}).",
+            code="network_unavailable",
+            details={
+                "service": "wdk-evm-wallet",
+                "http_status": response.status_code,
+            },
+        ) from exc
+    if response.status_code >= 400 or payload.get("ok") is False:
+        detail = payload.get("error") or f"HTTP {response.status_code}"
+        raise WalletBackendError(
+            str(detail),
+            code=str(payload.get("error_code") or "").strip() or None,
+            details=_error_details_from_payload(payload),
+        )
+    data = payload.get("data")
+    if not isinstance(data, list):
+        raise WalletBackendError("wdk-evm-wallet returned an invalid list response payload.")
+    wallets: list[dict[str, Any]] = []
+    for item in data:
+        if isinstance(item, dict):
+            wallets.append(dict(item))
+    return wallets
+
+
 class WdkEvmLocalClient:
     """Small client for the local EVM wallet service."""
 
@@ -203,3 +232,26 @@ class WdkEvmLocalClient:
                 details={"service": "wdk-evm-wallet", "path": path},
             ) from exc
         return _unwrap_payload(response)
+
+    def list_wallets_sync(self) -> list[dict[str, Any]]:
+        try:
+            with httpx.Client(
+                timeout=float(settings.http_timeout),
+                headers=self._headers,
+                follow_redirects=False,
+                trust_env=False,
+            ) as client:
+                response = client.get(f"{self.base_url}/v1/evm/wallets")
+        except httpx.TimeoutException as exc:
+            raise WalletBackendError(
+                "wdk-evm-wallet request timed out.",
+                code="network_unavailable",
+                details={"service": "wdk-evm-wallet", "path": "/v1/evm/wallets"},
+            ) from exc
+        except httpx.RequestError as exc:
+            raise WalletBackendError(
+                f"wdk-evm-wallet request failed: {exc}",
+                code="network_unavailable",
+                details={"service": "wdk-evm-wallet", "path": "/v1/evm/wallets"},
+            ) from exc
+        return _unwrap_list_payload(response)