@agentlayer.tech/wallet 0.1.17 → 0.1.18

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))