@agentlayer.tech/wallet 0.1.27 → 0.1.30

package/agent-wallet/agent_wallet/openclaw_runtime.py

@@ -7,7 +7,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.config import normalize_btc_network, normalize_evm_network, settings
 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
@@ -105,8 +105,7 @@ def onboard_openclaw_user_wallet(
             if wdk_btc_account_index is None
             else int(wdk_btc_account_index)
         )
-        requested_network = (network or settings.solana_network).strip().lower() or "bitcoin"
-        effective_network = "bitcoin" if requested_network == "mainnet" else requested_network
+        effective_network = normalize_btc_network(network or settings.solana_network)
         binding: dict[str, Any] | None = None
         wallet_id = str(wdk_btc_wallet_id or settings.wdk_btc_wallet_id).strip()
         if not service_url:
@@ -164,15 +163,7 @@ def onboard_openclaw_user_wallet(
             if wdk_evm_account_index is None
             else int(wdk_evm_account_index)
         )
-        requested_network = (network or settings.solana_network).strip().lower() or "ethereum"
-        aliases = {
-            "mainnet": "ethereum",
-            "eth": "ethereum",
-            "eth-mainnet": "ethereum",
-            "base-mainnet": "base",
-            "base_sepolia": "base-sepolia",
-        }
-        effective_network = aliases.get(requested_network, requested_network)
+        effective_network = normalize_evm_network(network or settings.solana_network)
         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.")

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

@@ -4,7 +4,7 @@ from __future__ import annotations
 
 from typing import Any
 
-from agent_wallet.config import settings
+from agent_wallet.config import normalize_solana_network, settings
 from agent_wallet.exceptions import ProviderError
 from agent_wallet.http_client import get_client
 
@@ -42,9 +42,7 @@ def _normalized_tx_response(data: Any, *, provider_name: str) -> dict[str, Any]:
 
 
 def _env_name(network: str) -> str:
-    normalized = str(network).strip().lower()
-    if normalized == "devnet":
-        return "devnet"
+    normalize_solana_network(network)
     return "mainnet-beta"
 
 
@@ -125,6 +123,25 @@ async def fetch_lend_user_rewards(*, user: str) -> dict[str, Any]:
     return data
 
 
+async def fetch_lend_loan_info(
+    *,
+    obligation: str,
+    network: str,
+) -> dict[str, Any]:
+    """Fetch a detailed Kamino loan report for one obligation."""
+    client = get_client()
+    response = await client.get(
+        f"{_normalized_api_base()}/klend/loans/{obligation}",
+        params={"env": _env_name(network)},
+    )
+    if response.status_code != 200:
+        raise ProviderError("kamino", f"HTTP {response.status_code}: {response.text[:300]}")
+    data = response.json()
+    if not isinstance(data, dict):
+        raise ProviderError("kamino", "Unexpected loan info response from Kamino.")
+    return data
+
+
 async def build_lend_deposit_transaction(
     *,
     wallet: str,

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

@@ -42,11 +42,6 @@ def _parse_gateway_url(rpc_url: str) -> tuple[str, str, str]:
 
 def _fallback_for_rpc_url(rpc_url: str) -> str:
     """Choose a cluster-appropriate official fallback URL."""
-    lowered = rpc_url.lower()
-    if "devnet" in lowered:
-        return "https://api.devnet.solana.com"
-    if "testnet" in lowered:
-        return "https://api.testnet.solana.com"
     return SOLANA_RPC_FALLBACK
 
 
@@ -415,24 +410,6 @@ async def simulate_transaction(
     }
 
 
-async def request_airdrop(
-    address: str,
-    lamports: int,
-    rpc_url: str,
-    commitment: str = "confirmed",
-) -> dict[str, Any]:
-    """Request a devnet or testnet SOL airdrop."""
-    data = await rpc_call(
-        "requestAirdrop",
-        [address, lamports, {"commitment": commitment}],
-        rpc_url=rpc_url,
-    )
-    return {
-        "signature": data.get("result"),
-        "source": "solana-rpc",
-    }
-
-
 async def get_signature_status(
     signature: str,
     rpc_url: str,

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

@@ -5,25 +5,24 @@ from __future__ import annotations
 import base64
 import hashlib
 import json
+import logging
 from typing import Any
 from urllib.parse import parse_qsl, urlencode, urlsplit, urlunsplit
 
-from agent_wallet.config import resolve_solana_rpc_url
+from agent_wallet.config import normalize_solana_network, resolve_solana_rpc_url
 from agent_wallet.exceptions import ProviderError
 from agent_wallet.http_client import get_client
 from agent_wallet.wallet_layer.base import AgentWalletBackend
 
 CDP_BAZAAR_DISCOVERY_BASE_URL = "https://api.cdp.coinbase.com/platform/v2/x402/discovery"
 AGENTIC_MARKET_API_BASE_URL = "https://api.agentic.market/v1"
+X402_EXECUTE_TIMEOUT_SECONDS = 45.0
 SOLANA_CAIP_BY_NETWORK = {
     "mainnet": "solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp",
-    "devnet": "solana:EtWTRABZaYq6iMfeYKouRu166VU2xqa1",
 }
 EVM_CAIP_BY_NETWORK = {
     "ethereum": "eip155:1",
     "base": "eip155:8453",
-    "sepolia": "eip155:11155111",
-    "base-sepolia": "eip155:84532",
 }
 _USDC_IDENTIFIERS = {
     "usdc",
@@ -32,6 +31,7 @@ _USDC_IDENTIFIERS = {
     "0x036cbd53842c5426634e7929541ec2318f3dcf7e",
     "epjfwdd5aufqssqem2qn1xzybapc8g4wegkgkzwytdt1v",
 }
+log = logging.getLogger("agent_wallet.x402")
 
 
 def _backend_chain(backend: AgentWalletBackend) -> str:
@@ -60,7 +60,7 @@ def _backend_solana_sdk_rpc_url(backend: AgentWalletBackend) -> str | None:
     if primary.startswith(("http://", "https://")):
         return primary
     network = _backend_network(backend)
-    fallback = resolve_solana_rpc_url(network or "mainnet", "")
+    fallback = resolve_solana_rpc_url(normalize_solana_network(network or "mainnet"), "")
     return _trim(fallback) or None
 
 
@@ -137,6 +137,13 @@ def _append_query(url: str, query: dict[str, str]) -> str:
     )
 
 
+def _request_host(url: str) -> str:
+    try:
+        return _trim(urlsplit(url).netloc).lower()
+    except Exception:
+        return ""
+
+
 def _response_text(response: Any) -> str:
     try:
         text = response.text
@@ -351,7 +358,7 @@ def _wallet_caip_networks(backend: AgentWalletBackend) -> list[str]:
 def _solana_exact_execution_supported(backend: AgentWalletBackend) -> bool:
     return (
         _backend_chain(backend) == "solana"
-        and _backend_network(backend) in {"mainnet", "devnet"}
+        and _backend_network(backend) == "mainnet"
         and getattr(backend, "signer", None) is not None
     )
 
@@ -359,7 +366,7 @@ def _solana_exact_execution_supported(backend: AgentWalletBackend) -> bool:
 def _evm_exact_execution_supported(backend: AgentWalletBackend) -> bool:
     return (
         _backend_chain(backend) == "evm"
-        and _backend_network(backend) in {"base", "base-sepolia"}
+        and _backend_network(backend) == "base"
         and callable(getattr(backend, "sign_x402_evm_exact_typed_data", None))
     )
 
@@ -378,9 +385,7 @@ def _wallet_x402_support_summary(backend: AgentWalletBackend) -> dict[str, Any]:
     supported_networks = _wallet_caip_networks(backend)
     planned_execution_networks = {
         "eip155:8453",
-        "eip155:84532",
         "solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp",
-        "solana:EtWTRABZaYq6iMfeYKouRu166VU2xqa1",
     }
     execution_modes: list[str] = []
     if _solana_exact_execution_supported(backend):
@@ -513,6 +518,7 @@ def _build_request_metadata(
     )
     return {
         "url": final_url,
+        "host": _request_host(final_url),
         "method": http_method,
         "headers": normalized_headers,
         "query": normalized_query,
@@ -529,6 +535,7 @@ async def _send_request(
     client: Any,
     request: dict[str, Any],
     extra_headers: dict[str, str] | None = None,
+    timeout: float | None = None,
 ) -> Any:
     headers = dict(request["headers"])
     if extra_headers:
@@ -539,6 +546,7 @@ async def _send_request(
         headers=headers,
         json=request["json_body"] if request["json_body"] is not None else None,
         content=request["text_body"] if request["text_body"] is not None else None,
+        timeout=timeout,
     )
 
 
@@ -671,6 +679,96 @@ def _require_executable_payment(
     return selected
 
 
+def _validate_payment_requirement(
+    selected: dict[str, Any] | None,
+    *,
+    backend: AgentWalletBackend,
+    request_url: str,
+) -> dict[str, Any]:
+    if not isinstance(selected, dict):
+        raise ProviderError(
+            "x402-validate",
+            "This endpoint returned HTTP 402 but no compatible payment option was found for the active wallet.",
+            details={
+                "request_url": request_url,
+                "wallet_chain": _backend_chain(backend),
+                "wallet_network": _backend_network(backend),
+            },
+        )
+
+    scheme = _trim(selected.get("scheme")).lower()
+    if scheme != "exact":
+        raise ProviderError(
+            "x402-validate",
+            f"Unsupported x402 payment scheme '{scheme or 'unknown'}'. Only 'exact' is supported.",
+            details={"request_url": request_url, "selected_payment": selected},
+        )
+
+    if not _trim(selected.get("pay_to")):
+        raise ProviderError(
+            "x402-validate",
+            "Payment destination (payTo) is missing from the x402 requirement.",
+            details={"request_url": request_url, "selected_payment": selected},
+        )
+
+    compatibility = _requirement_compatibility(selected, backend)
+    if compatibility["currently_executable"]:
+        return selected
+
+    chain = _backend_chain(backend) or "unknown"
+    network = _backend_network(backend) or "unknown"
+    requirement_network = _trim(selected.get("network")) or "unknown"
+    if chain == "solana" and requirement_network not in SOLANA_CAIP_BY_NETWORK.values():
+        message = (
+            f"This endpoint requires payment on {requirement_network}, but the active wallet is Solana ({network})."
+        )
+    elif chain == "evm" and requirement_network not in EVM_CAIP_BY_NETWORK.values():
+        message = (
+            f"This endpoint requires payment on {requirement_network}, but the active wallet is EVM ({network})."
+        )
+    else:
+        message = str(compatibility["reason"])
+
+    raise ProviderError(
+        "x402-validate",
+        message,
+        details={
+            "request_url": request_url,
+            "selected_payment": selected,
+            "compatibility": compatibility,
+        },
+    )
+
+
+def _validate_request_execution_policy(
+    *,
+    request: dict[str, Any],
+    backend: AgentWalletBackend,
+) -> None:
+    host = _trim(request.get("host")).lower()
+    if host == "x402.alchemy.com":
+        headers = request.get("headers")
+        has_auth = isinstance(headers, dict) and any(
+            str(key).strip().lower() == "authorization" and str(value).strip()
+            for key, value in headers.items()
+        )
+        if not has_auth:
+            raise ProviderError(
+                "x402-validate",
+                (
+                    "Alchemy's x402 gateway needs wallet-auth headers in addition to the payment challenge. "
+                    "The generic x402 tool does not mint Alchemy SIWE/SIWS auth tokens yet, so this endpoint "
+                    "is not safe to execute through the generic flow."
+                ),
+                details={
+                    "request_url": request.get("url"),
+                    "host": host,
+                    "wallet_chain": _backend_chain(backend),
+                    "wallet_network": _backend_network(backend),
+                    "hint": "Use a dedicated Alchemy agent gateway integration or authenticated CLI flow.",
+                },
+            )
+
 def _select_sdk_payment_requirement(
     payment_required: Any,
     *,
@@ -940,15 +1038,57 @@ async def _create_payment_headers(
     )
 
 
-def _extract_settlement_header(response: Any) -> dict[str, Any] | None:
+def _extract_settlement_header(response: Any) -> dict[str, Any]:
     sdk = _load_x402_sdk()
+    settle = sdk["x402HTTPClientBase"]().get_payment_settle_response(
+        lambda name: response.headers.get(name)
+    )
+    return settle.model_dump(by_alias=True, exclude_none=True)
+
+
+def _extract_settlement_header_safe(response: Any) -> dict[str, Any] | None:
     try:
-        settle = sdk["x402HTTPClientBase"]().get_payment_settle_response(
-            lambda name: response.headers.get(name)
+        return _extract_settlement_header(response)
+    except Exception as exc:
+        log.warning(
+            "x402 settlement header parse failed",
+            extra={
+                "status_code": getattr(response, "status_code", None),
+                "payment_response": response.headers.get("PAYMENT-RESPONSE")
+                if hasattr(response, "headers")
+                else None,
+                "x_payment_response": response.headers.get("X-PAYMENT-RESPONSE")
+                if hasattr(response, "headers")
+                else None,
+                "error_type": type(exc).__name__,
+                "error": str(exc) or None,
+            },
         )
-    except Exception:
         return None
-    return settle.model_dump(by_alias=True, exclude_none=True)
+
+
+def _log_x402_execute(
+    *,
+    request: dict[str, Any],
+    selected_payment: dict[str, Any] | None,
+    response: Any,
+    settlement: dict[str, Any] | None,
+) -> None:
+    log.info(
+        "x402 execute completed",
+        extra={
+            "url": request.get("url"),
+            "method": request.get("method"),
+            "request_fingerprint": request.get("request_fingerprint"),
+            "x402_network": selected_payment.get("network") if isinstance(selected_payment, dict) else None,
+            "x402_asset": selected_payment.get("asset") if isinstance(selected_payment, dict) else None,
+            "x402_amount": selected_payment.get("amount") if isinstance(selected_payment, dict) else None,
+            "x402_pay_to": selected_payment.get("pay_to") if isinstance(selected_payment, dict) else None,
+            "status_code": getattr(response, "status_code", None),
+            "transaction": settlement.get("transaction") if isinstance(settlement, dict) else None,
+            "confirmed": bool(settlement and settlement.get("success")),
+        },
+    )
 
 
 async def search_services(
@@ -1250,6 +1390,29 @@ async def execute_request(
     query: dict[str, Any] | None = None,
     json_body: Any | None = None,
     text_body: str | None = None,
+) -> dict[str, Any]:
+    executed = await pay_and_fetch(
+        backend=backend,
+        url=url,
+        method=method,
+        headers=headers,
+        query=query,
+        json_body=json_body,
+        text_body=text_body,
+    )
+    executed["mode"] = "execute"
+    return executed
+
+
+async def pay_and_fetch(
+    *,
+    backend: AgentWalletBackend,
+    url: str,
+    method: str = "GET",
+    headers: dict[str, Any] | None = None,
+    query: dict[str, Any] | None = None,
+    json_body: Any | None = None,
+    text_body: str | None = None,
 ) -> dict[str, Any]:
     preview = await preview_request(
         backend=backend,
@@ -1268,7 +1431,13 @@ async def execute_request(
         executed["confirmed"] = False
         return executed
 
-    selected_payment = _require_executable_payment(preview=preview, backend=backend)
+    selected_payment = _validate_payment_requirement(
+        preview.get("selected_payment")
+        if isinstance(preview.get("selected_payment"), dict)
+        else None,
+        backend=backend,
+        request_url=str(preview.get("request_url") or url),
+    )
     payment_required_header = (
         dict(preview.get("response_headers") or {}).get("payment-required")
     )
@@ -1283,15 +1452,26 @@ async def execute_request(
         json_body=json_body,
         text_body=text_body,
     )
+    _validate_request_execution_policy(request=request, backend=backend)
     payment_headers = await _create_payment_headers(
         backend=backend,
         payment_required_header=payment_required_header,
         selected_payment=selected_payment,
     )
-    payment_headers["Access-Control-Expose-Headers"] = "PAYMENT-RESPONSE,X-PAYMENT-RESPONSE"
     client = get_client()
-    response = await _send_request(client=client, request=request, extra_headers=payment_headers)
-    settlement = _extract_settlement_header(response)
+    response = await _send_request(
+        client=client,
+        request=request,
+        extra_headers=payment_headers,
+        timeout=X402_EXECUTE_TIMEOUT_SECONDS,
+    )
+    settlement = _extract_settlement_header_safe(response)
+    _log_x402_execute(
+        request=request,
+        selected_payment=selected_payment,
+        response=response,
+        settlement=settlement,
+    )
 
     executed = dict(preview)
     executed.update(

package/agent-wallet/agent_wallet/user_wallets.py

@@ -14,6 +14,7 @@ from agent_wallet.bootstrap import (
 )
 from agent_wallet.config import (
     allow_plaintext_user_wallet_migration,
+    normalize_solana_network,
     resolve_openclaw_home,
     resolve_runtime_solana_rpc_config,
     resolve_runtime_solana_swap_config,
@@ -46,13 +47,13 @@ def normalize_user_id(user_id: str) -> str:
 
 def resolve_user_wallet_path(user_id: str, network: str | None = None) -> Path:
     """Resolve the wallet file path for a given OpenClaw user."""
-    effective_network = (network or settings.solana_network).strip().lower() or "mainnet"
+    effective_network = normalize_solana_network(network or settings.solana_network)
     user_dir = resolve_openclaw_home() / "users" / normalize_user_id(user_id) / "wallets"
     return user_dir / f"solana-{effective_network}-agent.json"
 
 
 def _user_wallet_metadata(user_id: str, address: str, network: str | None = None) -> dict[str, str]:
-    effective_network = (network or settings.solana_network).strip().lower() or "mainnet"
+    effective_network = normalize_solana_network(network or settings.solana_network)
     return {
         "address": address,
         "user_id": user_id,
@@ -61,7 +62,7 @@ def _user_wallet_metadata(user_id: str, address: str, network: str | None = None
 
 
 def _resolve_effective_network(network: str | None = None) -> str:
-    return (network or settings.solana_network).strip().lower() or "mainnet"
+    return normalize_solana_network(network or settings.solana_network)
 
 
 def _resolve_user_wallet_master_key(

package/agent-wallet/agent_wallet/wallet_layer/base.py

@@ -520,6 +520,9 @@ class AgentWalletBackend(ABC):
     async def get_kamino_lend_user_rewards(self, user: str | None = None) -> dict[str, Any]:
         raise WalletBackendError(f"{self.name} does not support Kamino rewards lookup.")
 
+    async def get_kamino_open_positions(self, user: str | None = None) -> dict[str, Any]:
+        raise WalletBackendError(f"{self.name} does not support Kamino open position lookup.")
+
     async def preview_kamino_lend_deposit(
         self,
         market: str,
@@ -994,9 +997,6 @@ class AgentWalletBackend(ABC):
             ),
         )
 
-    async def request_testnet_airdrop(self, amount_native: float) -> dict[str, Any]:
-        raise WalletBackendError(f"{self.name} does not support testnet airdrops.")
-
     async def preview_native_stake(
         self,
         vote_account: str,

package/agent-wallet/agent_wallet/wallet_layer/factory.py

@@ -7,6 +7,8 @@ from pathlib import Path
 from agent_wallet.bootstrap import ensure_solana_wallet_ready, ensure_wallet_pin
 from agent_wallet.encrypted_storage import load_wallet_secret_material
 from agent_wallet.config import (
+    normalize_btc_network,
+    normalize_solana_network,
     resolve_runtime_solana_rpc_config,
     resolve_runtime_solana_swap_config,
     resolve_solana_private_key,
@@ -44,6 +46,7 @@ def create_wallet_backend() -> AgentWalletBackend | None:
         return None
 
     if backend in {"solana", "solana_local", "solana-local"}:
+        solana_network = normalize_solana_network(settings.solana_network)
         secret_material = _load_keypair_material()
         signer = (
             SolanaLocalKeypairSigner.from_secret_material(secret_material)
@@ -55,19 +58,19 @@ def create_wallet_backend() -> AgentWalletBackend | None:
             ensure_wallet_pin(
                 Path(keypair_path).expanduser(),
                 address=signer.address,
-                network=settings.solana_network,
+                network=solana_network,
             )
         configured_address = settings.solana_agent_public_key.strip() or None
         rpc_config = resolve_runtime_solana_rpc_config(
-            settings.solana_network,
+            solana_network,
             settings.solana_rpc_url,
             settings.solana_rpc_urls,
         )
-        swap_config = resolve_runtime_solana_swap_config(settings.solana_network)
+        swap_config = resolve_runtime_solana_swap_config(solana_network)
         return SolanaWalletBackend(
             rpc_url=rpc_config["rpc_urls"],
             commitment=settings.solana_commitment,
-            network=settings.solana_network,
+            network=solana_network,
             signer=signer,
             address=configured_address,
             sign_only=settings.agent_wallet_sign_only,
@@ -82,7 +85,7 @@ def create_wallet_backend() -> AgentWalletBackend | None:
         return WdkBtcLocalWalletBackend(
             service_url=settings.wdk_btc_service_url,
             wallet_id=settings.wdk_btc_wallet_id,
-            network=settings.solana_network,
+            network=normalize_btc_network(settings.solana_network),
             account_index=settings.wdk_btc_account_index,
             sign_only=settings.agent_wallet_sign_only,
         )