@agentlayer.tech/wallet 0.1.24 → 0.1.26

package/.openclaw/extensions/agent-wallet/openclaw.plugin.json

@@ -222,6 +222,10 @@
         "type": "string",
         "description": "Optional Jupiter Swap API base URL."
       },
+      "jupiterSwapV2BaseUrl": {
+        "type": "string",
+        "description": "Optional Jupiter Swap API V2 base URL."
+      },
       "jupiterUltraBaseUrl": {
         "type": "string",
         "description": "Optional Jupiter Ultra API base URL."

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

@@ -11,9 +11,12 @@ Safety rules:
 - Use Kamino market/reserve reads before Kamino writes when the user needs lending context.
 - Use Aave account reads before Aave writes when the user needs EVM lending context.
 - For transfers, native staking, swaps, Aave writes, Jupiter Earn writes, and Kamino writes, use `preview` before `prepare` or `execute`.
+- For Solana Jupiter swaps through `swap_solana_tokens`, prefer `intent_preview` then `intent_execute` after explicit chat confirmation. The user confirms risk limits; the backend refreshes the quote and only executes inside those limits.
+- Solana swap intent defaults to at least 300 bps (3%) slippage, 120 seconds validity, and 3 fresh execution attempts. The backend computes the approved minimum output from the indicative output and slippage, clamps hand-tightened minimums to that floor, then executes through Jupiter Swap API V2 `/order` + `/execute` when available.
+- Do not use legacy `execute` for Solana Jupiter swaps in OpenClaw. Exact quote-bound approval is too fragile for active markets and will be rejected by the bridge.
 - For `swap_solana_privately`, use `preview` and then `execute` after explicit user approval. Do not use `prepare` for this tool.
 - Use `prepare` only when the user clearly intends to produce an execution plan.
-- Use `execute` only after the host issues an `approval_token` bound to the exact previewed operation.
+- Use `execute` only after the user explicitly confirms the shown summary in chat. OpenClaw handles the internal approval token; do not ask for `/approve`, buttons, popups, or a manual token. For Solana swap intents, the token is bound to the approved intent limits instead of one fragile quote.
 - On `mainnet`, require an approval token that includes explicit mainnet confirmation before any execution.
 - Before any `mainnet` execute, restate the network, operation type, asset, amount, and destination, validator, or stake account.
 - If a preview or prepare result includes `confirmation_summary` or `mainnet_warning`, surface that summary before asking for confirmation.

package/CHANGELOG.md

@@ -2,6 +2,20 @@
 
 ## Unreleased
 
+## v0.1.26 - 2026-05-26
+
+- Reworked Solana Jupiter swaps to prefer intent approvals, so OpenClaw confirms
+  risk limits and executes against a fresh quote instead of binding approval to
+  a fragile exact quote payload.
+- Added Jupiter Swap API V2 `/order` + `/execute` routing with managed landing
+  support and fallback routing for Solana swaps.
+- Hardened Solana swap intent defaults to 3% slippage, a 120-second execution
+  window, three fresh execution attempts, and safer minimum-output handling.
+- Fixed Jupiter V2 execution payload compatibility by sending
+  `lastValidBlockHeight` in the string form expected by the API.
+- Disabled legacy exact-preview Solana swap execute in the OpenClaw bridge to
+  prevent stale approval-token mismatches on active markets.
+
 ## v0.1.24 - 2026-05-23
 
 - Fixed the published npm package CLI metadata so

package/agent-wallet/README.md

@@ -88,7 +88,7 @@ Current safe tools:
 - `transfer_sol`
 - `stake_sol_native`
 - `transfer_spl_token`
-- `swap_solana_tokens`
+- `swap_solana_tokens` - Solana Jupiter swaps; prefer `intent_preview` -> chat confirmation -> `intent_execute` so execution refreshes the quote inside approved limits.
 - `swap_solana_privately` - Houdini-backed private Solana payout flow for same-token `SOL->SOL` or `USDC->USDC` transfers to a destination wallet.
 - `get_solana_private_swap_status`
 - `get_jupiter_earn_tokens`
@@ -129,8 +129,9 @@ Policy defaults:
 - read-only tools are always allowed
 - `prepare` requires `user_intent=true`
 - `prepare` does not return signed transaction bytes
-- `execute` requires a host-issued `approval_token` bound to the exact previewed operation
-- on mainnet networks, that `approval_token` must include explicit mainnet confirmation
+- backend `execute` requires an internal authorization token bound to the exact previewed operation
+- in OpenClaw, the extension handles that internal authorization automatically after the user explicitly confirms the shown summary in chat; do not ask OpenClaw users for `/approve`, buttons, popups, or a manual token
+- on mainnet networks, that internal authorization must include explicit mainnet confirmation
 - on mainnet networks, preview and prepare responses include a `confirmation_summary` and `mainnet_warning` to force a clearer final confirmation step
 
 ## Install

package/agent-wallet/agent_wallet/config.py

@@ -45,6 +45,7 @@ class Settings(BaseSettings):
     wdk_evm_account_index: int = 0
 
     jupiter_api_base_url: str = "https://lite-api.jup.ag/swap/v1"
+    jupiter_swap_v2_api_base_url: str = "https://api.jup.ag/swap/v2"
     jupiter_ultra_api_base_url: str = "https://lite-api.jup.ag/ultra/v1"
     jupiter_price_api_base_url: str = "https://lite-api.jup.ag/price/v3"
     jupiter_portfolio_api_base_url: str = "https://api.jup.ag/portfolio/v1"

package/agent-wallet/agent_wallet/openclaw_adapter.py

@@ -352,6 +352,28 @@ class OpenClawWalletAdapter:
                     summary[key] = value
             return summary
 
+        if asset_type == "solana-swap-intent":
+            return {
+                "operation": action_label,
+                "network": str(payload.get("network") or getattr(self.backend, "network", "unknown")),
+                "owner": payload.get("owner"),
+                "input_mint": payload.get("input_mint"),
+                "output_mint": payload.get("output_mint"),
+                "input_amount_ui": payload.get("input_amount_ui"),
+                "input_amount_raw": payload.get("input_amount_raw"),
+                "minimum_output_amount_raw": payload.get("minimum_output_amount_raw"),
+                "minimum_output_amount_ui": payload.get("minimum_output_amount_ui"),
+                "max_slippage_bps": payload.get("max_slippage_bps"),
+                "slippage_bps": payload.get("slippage_bps"),
+                "max_fee_lamports": payload.get("max_fee_lamports"),
+                "valid_until_epoch_seconds": payload.get("valid_until_epoch_seconds"),
+                "valid_for_seconds": payload.get("valid_for_seconds"),
+                "max_attempts": payload.get("max_attempts"),
+                "allowed_providers": payload.get("allowed_providers"),
+                "recipient_policy": payload.get("recipient_policy"),
+                "spend_policy": payload.get("spend_policy"),
+            }
+
         if asset_type == "solana-lifi-cross-chain-swap":
             return {
                 "operation": action_label,
@@ -2451,7 +2473,9 @@ class OpenClawWalletAdapter:
                     name="swap_solana_tokens",
                     description=(
                         "Preview or execute a Solana token swap through Jupiter routing. "
-                        "Use preview first, then execute only after explicit user approval."
+                        "Prefer intent_preview, then intent_execute after explicit chat confirmation; "
+                        "intent_execute fetches a fresh quote and only sends if it remains inside the approved limits. "
+                        "OpenClaw should not use legacy execute for Solana swaps because exact Jupiter quote payloads expire quickly."
                     ),
                     input_schema={
                         "type": "object",
@@ -2470,12 +2494,28 @@ class OpenClawWalletAdapter:
                             },
                             "slippage_bps": {
                                 "type": "integer",
-                                "description": "Optional slippage tolerance in basis points. Defaults to 50.",
+                                "description": "Optional slippage tolerance in basis points. Defaults to 300 (3%) for Solana swaps.",
+                            },
+                            "minimum_output_amount_raw": {
+                                "type": "integer",
+                                "description": "Optional approved minimum output in raw output token units for intent_preview. For intent swaps, overly strict values are clamped to the slippage floor.",
+                            },
+                            "max_fee_lamports": {
+                                "type": "integer",
+                                "description": "Optional maximum Solana network fee in lamports for intent_preview.",
+                            },
+                            "valid_for_seconds": {
+                                "type": "integer",
+                                "description": "Optional intent validity window in seconds. Intent swaps use at least 120 seconds, max 120.",
+                            },
+                            "max_attempts": {
+                                "type": "integer",
+                                "description": "Optional number of fresh quote/simulate/execute attempts. Intent swaps use at least 3 attempts, max 5.",
                             },
                             "mode": {
                                 "type": "string",
-                                "enum": ["preview", "prepare", "execute"],
-                                "description": "preview returns a quote, prepare returns an execution plan without signed transaction bytes, execute attempts to swap.",
+                                "enum": ["preview", "prepare", "execute", "intent_preview", "intent_execute"],
+                                "description": "intent_preview returns approved risk limits; intent_execute requotes and executes atomically inside those limits. Legacy preview/prepare/execute remains supported.",
                             },
                             "purpose": {
                                 "type": "string",
@@ -4428,19 +4468,6 @@ class OpenClawWalletAdapter:
                         raise WalletBackendError(
                             "approved preview payload does not match the approval token. Generate a new preview and approval before execute."
                         )
-                    preview_summary = self._build_confirmation_summary(
-                        action_label="Flash Trade open position",
-                        payload=approved_preview,
-                    )
-                    summary_without_digest = {
-                        key: value
-                        for key, value in approval_summary_copy.items()
-                        if key != "_preview_digest"
-                    }
-                    if preview_summary != summary_without_digest:
-                        raise WalletBackendError(
-                            "approved preview payload does not match the approval token. Generate a new preview and approval before execute."
-                        )
                     execute_preview = dict(approved_preview)
                 else:
                     execute_preview = await active_backend.preview_flash_trade_open_position(
@@ -4567,19 +4594,6 @@ class OpenClawWalletAdapter:
                         raise WalletBackendError(
                             "approved preview payload does not match the approval token. Generate a new preview and approval before execute."
                         )
-                    preview_summary = self._build_confirmation_summary(
-                        action_label="Flash Trade close position",
-                        payload=approved_preview,
-                    )
-                    summary_without_digest = {
-                        key: value
-                        for key, value in approval_summary_copy.items()
-                        if key != "_preview_digest"
-                    }
-                    if preview_summary != summary_without_digest:
-                        raise WalletBackendError(
-                            "approved preview payload does not match the approval token. Generate a new preview and approval before execute."
-                        )
                     execute_preview = dict(approved_preview)
                 else:
                     execute_preview = await active_backend.preview_flash_trade_close_position(
@@ -5274,7 +5288,11 @@ class OpenClawWalletAdapter:
                 input_mint = args.get("input_mint")
                 output_mint = args.get("output_mint")
                 amount = args.get("amount")
-                slippage_bps = args.get("slippage_bps", 50)
+                slippage_bps = args.get("slippage_bps", 300)
+                minimum_output_amount_raw = args.get("minimum_output_amount_raw")
+                max_fee_lamports = args.get("max_fee_lamports")
+                valid_for_seconds = args.get("valid_for_seconds", 120)
+                max_attempts = args.get("max_attempts", 3)
                 mode = args.get("mode")
                 purpose = args.get("purpose")
                 user_intent = args.get("user_intent", False)
@@ -5288,10 +5306,28 @@ class OpenClawWalletAdapter:
                     raise WalletBackendError("amount must be a positive number.")
                 if not isinstance(slippage_bps, int) or slippage_bps <= 0:
                     raise WalletBackendError("slippage_bps must be a positive integer.")
-                if mode not in {"preview", "prepare", "execute"}:
-                    raise WalletBackendError("mode must be 'preview', 'prepare' or 'execute'.")
+                if minimum_output_amount_raw is not None and (
+                    not isinstance(minimum_output_amount_raw, int) or minimum_output_amount_raw <= 0
+                ):
+                    raise WalletBackendError("minimum_output_amount_raw must be a positive integer when provided.")
+                if max_fee_lamports is not None and (
+                    not isinstance(max_fee_lamports, int) or max_fee_lamports < 0
+                ):
+                    raise WalletBackendError("max_fee_lamports must be a non-negative integer when provided.")
+                if not isinstance(valid_for_seconds, int) or valid_for_seconds <= 0 or valid_for_seconds > 120:
+                    raise WalletBackendError("valid_for_seconds must be an integer between 1 and 120.")
+                if not isinstance(max_attempts, int) or max_attempts <= 0 or max_attempts > 5:
+                    raise WalletBackendError("max_attempts must be an integer between 1 and 5.")
+                if mode not in {"preview", "prepare", "execute", "intent_preview", "intent_execute"}:
+                    raise WalletBackendError(
+                        "mode must be 'preview', 'prepare', 'execute', 'intent_preview' or 'intent_execute'."
+                    )
                 if not isinstance(purpose, str) or not purpose.strip():
                     raise WalletBackendError("purpose is required.")
+                if mode in {"intent_preview", "intent_execute"}:
+                    slippage_bps = max(slippage_bps, 300)
+                    valid_for_seconds = max(valid_for_seconds, 120)
+                    max_attempts = max(max_attempts, 3)
 
                 if mode == "preview":
                     preview = await self.backend.preview_swap(
@@ -5310,6 +5346,27 @@ class OpenClawWalletAdapter:
                         ),
                     )
 
+                if mode == "intent_preview":
+                    intent_preview = await self.backend.preview_swap_intent(
+                        input_mint=input_mint.strip(),
+                        output_mint=output_mint.strip(),
+                        amount_ui=float(amount),
+                        slippage_bps=slippage_bps,
+                        minimum_output_amount_raw=minimum_output_amount_raw,
+                        max_fee_lamports=max_fee_lamports,
+                        valid_for_seconds=valid_for_seconds,
+                        max_attempts=max_attempts,
+                    )
+                    return AgentToolResult(
+                        tool=tool_name,
+                        ok=True,
+                        data=self._annotate_sensitive_payload(
+                            intent_preview,
+                            action_label="Swap intent",
+                            mode="preview",
+                        ),
+                    )
+
                 if mode == "prepare":
                     self._require_prepare_intent(user_intent)
                     preview = await self.backend.preview_swap(
@@ -5331,6 +5388,103 @@ class OpenClawWalletAdapter:
                         ),
                     )
 
+                if mode == "intent_execute":
+                    approval_payload = inspect_approval_token(
+                        approval_token,
+                        tool_name=tool_name,
+                        network=str(getattr(self.backend, "network", "unknown")),
+                        require_mainnet_confirmation=self._is_mainnet_for_backend(self.backend),
+                    )
+                    approval_summary = approval_payload.get("binding", {}).get("summary")
+                    if not isinstance(approval_summary, dict):
+                        raise WalletBackendError(
+                            "approval_token does not match the requested operation. Generate a new intent preview and approval before execute."
+                        )
+                    expected_summary = {
+                        "operation": "Swap intent",
+                        "network": str(getattr(self.backend, "network", "unknown")),
+                        "input_mint": input_mint.strip(),
+                        "output_mint": output_mint.strip(),
+                    }
+                    for key, expected_value in expected_summary.items():
+                        if approval_summary.get(key) != expected_value:
+                            raise WalletBackendError(
+                                "approval_token does not match the requested swap intent. Generate a fresh intent preview and approval before execute."
+                            )
+                    current_owner = await self.backend.get_address()
+                    approved_owner = approval_summary.get("owner")
+                    if approved_owner and current_owner and str(approved_owner) != str(current_owner):
+                        raise WalletBackendError(
+                            "approval_token does not match the active wallet owner. Generate a fresh intent preview and approval before execute."
+                        )
+                    try:
+                        approved_amount = float(approval_summary.get("input_amount_ui"))
+                        approved_slippage = int(
+                            approval_summary.get("max_slippage_bps")
+                            if approval_summary.get("max_slippage_bps") is not None
+                            else approval_summary.get("slippage_bps")
+                        )
+                    except (TypeError, ValueError):
+                        raise WalletBackendError(
+                            "approval_token does not match the requested swap intent. Generate a fresh intent preview and approval before execute."
+                        )
+                    if approved_amount != float(amount) or approved_slippage != slippage_bps:
+                        raise WalletBackendError(
+                            "approval_token does not match the requested swap intent. Generate a fresh intent preview and approval before execute."
+                        )
+                    if approval_summary.get("recipient_policy") != "owner-only":
+                        raise WalletBackendError("approved swap intent recipient policy is invalid.")
+                    if approval_summary.get("spend_policy") != "exact-input":
+                        raise WalletBackendError("approved swap intent spend policy is invalid.")
+
+                    approval_summary_copy = dict(approval_summary)
+                    self._require_execute_approval(
+                        approval_token=approval_token,
+                        tool_name=tool_name,
+                        summary=approval_summary_copy,
+                        action_label="Swap intent",
+                    )
+                    try:
+                        approved_min_output_raw = (
+                            int(approval_summary_copy["minimum_output_amount_raw"])
+                            if approval_summary_copy.get("minimum_output_amount_raw") is not None
+                            else None
+                        )
+                        approved_max_fee_lamports = (
+                            int(approval_summary_copy["max_fee_lamports"])
+                            if approval_summary_copy.get("max_fee_lamports") is not None
+                            else None
+                        )
+                        approved_valid_until = (
+                            int(approval_summary_copy["valid_until_epoch_seconds"])
+                            if approval_summary_copy.get("valid_until_epoch_seconds") is not None
+                            else None
+                        )
+                        approved_max_attempts = int(approval_summary_copy.get("max_attempts") or max_attempts)
+                    except (TypeError, ValueError):
+                        raise WalletBackendError(
+                            "approval_token does not contain valid swap intent limits. Generate a fresh intent preview and approval before execute."
+                        )
+                    result = await self.backend.execute_swap_intent(
+                        input_mint=input_mint.strip(),
+                        output_mint=output_mint.strip(),
+                        amount_ui=float(amount),
+                        slippage_bps=slippage_bps,
+                        minimum_output_amount_raw=approved_min_output_raw,
+                        max_fee_lamports=approved_max_fee_lamports,
+                        valid_until_epoch_seconds=approved_valid_until,
+                        max_attempts=approved_max_attempts,
+                    )
+                    return AgentToolResult(
+                        tool=tool_name,
+                        ok=True,
+                        data=self._annotate_sensitive_payload(
+                            result,
+                            action_label="Swap",
+                            mode="execute",
+                        ),
+                    )
+
                 approval_payload = inspect_approval_token(
                     approval_token,
                     tool_name=tool_name,
@@ -5376,19 +5530,6 @@ class OpenClawWalletAdapter:
                         raise WalletBackendError(
                             "approved preview payload does not match the approval token. Generate a new preview and approval before execute."
                         )
-                    preview_summary = self._build_confirmation_summary(
-                        action_label="Swap",
-                        payload=approved_preview,
-                    )
-                    summary_without_digest = {
-                        key: value
-                        for key, value in approval_summary_copy.items()
-                        if key != "_preview_digest"
-                    }
-                    if preview_summary != summary_without_digest:
-                        raise WalletBackendError(
-                            "approved preview payload does not match the approval token. Generate a new preview and approval before execute."
-                        )
                     execute_preview = dict(approved_preview)
                 else:
                     execute_preview = await self.backend.preview_swap(
@@ -5525,19 +5666,6 @@ class OpenClawWalletAdapter:
                         raise WalletBackendError(
                             "approved preview payload does not match the approval token. Generate a new preview and approval before execute."
                         )
-                    preview_summary = self._build_confirmation_summary(
-                        action_label="Solana private swap",
-                        payload=approved_preview,
-                    )
-                    summary_without_digest = {
-                        key: value
-                        for key, value in approval_summary_copy.items()
-                        if key != "_preview_digest"
-                    }
-                    if preview_summary != summary_without_digest:
-                        raise WalletBackendError(
-                            "approved preview payload does not match the approval token. Generate a new preview and approval before execute."
-                        )
                     execute_preview = dict(approved_preview)
 
                 self._require_execute_approval(
@@ -5593,20 +5721,6 @@ class OpenClawWalletAdapter:
                         raise WalletBackendError(
                             "approved preview payload does not match the approval token. Generate a new preview and approval before continue."
                         )
-                    preview_summary = self._build_confirmation_summary(
-                        action_label="Solana private swap",
-                        payload=approved_preview,
-                    )
-                    summary_without_digest = {
-                        key: value
-                        for key, value in approval_summary_copy.items()
-                        if key != "_preview_digest"
-                    }
-                    if preview_summary != summary_without_digest:
-                        raise WalletBackendError(
-                            "approved preview payload does not match the approval token. Generate a new preview and approval before continue."
-                        )
-
                 self._require_execute_approval(
                     approval_token=approval_token,
                     tool_name="swap_solana_privately",

package/agent-wallet/agent_wallet/openclaw_cli.py

@@ -93,6 +93,7 @@ def _apply_config_overrides(config: dict[str, Any]) -> None:
         ),
         "openclawHome": ("OPENCLAW_HOME", config.get("openclawHome"), True),
         "jupiterBaseUrl": ("JUPITER_API_BASE_URL", config.get("jupiterBaseUrl"), True),
+        "jupiterSwapV2BaseUrl": ("JUPITER_SWAP_V2_API_BASE_URL", config.get("jupiterSwapV2BaseUrl"), True),
         "jupiterUltraBaseUrl": ("JUPITER_ULTRA_API_BASE_URL", config.get("jupiterUltraBaseUrl"), True),
         "jupiterPriceBaseUrl": ("JUPITER_PRICE_API_BASE_URL", config.get("jupiterPriceBaseUrl"), True),
         "jupiterPortfolioBaseUrl": (

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

@@ -91,6 +91,13 @@ def _direct_jupiter_enabled() -> bool:
     return bool(settings.jupiter_api_key.strip())
 
 
+def _swap_v2_base_url() -> str:
+    return os.getenv(
+        "JUPITER_SWAP_V2_API_BASE_URL",
+        settings.jupiter_swap_v2_api_base_url,
+    ).strip().rstrip("/")
+
+
 def _unwrap_gateway_payload(
     status_code: int,
     payload: Any,
@@ -367,6 +374,52 @@ async def fetch_ultra_order(
     return data
 
 
+async def fetch_swap_v2_order(
+    *,
+    input_mint: str,
+    output_mint: str,
+    amount_raw: int,
+    taker: str,
+    slippage_bps: int | str | None = None,
+    exclude_routers: list[str] | None = None,
+    swap_mode: str = "ExactIn",
+) -> dict[str, Any]:
+    """Fetch a Jupiter Swap API V2 meta-aggregator order."""
+    client = get_client()
+    params: dict[str, Any] = {
+        "inputMint": input_mint,
+        "outputMint": output_mint,
+        "amount": str(amount_raw),
+        "taker": taker,
+    }
+    if swap_mode != "ExactIn":
+        params["swapMode"] = swap_mode
+    if slippage_bps is not None:
+        params["slippageBps"] = str(slippage_bps)
+    if exclude_routers:
+        params["excludeRouters"] = ",".join(str(item).strip() for item in exclude_routers if str(item).strip())
+
+    response = await client.get(
+        f"{_swap_v2_base_url()}/order",
+        params=params,
+        headers=_headers(),
+    )
+    if response.status_code != 200:
+        raise ProviderError("jupiter-v2", f"HTTP {response.status_code}: {response.text[:300]}")
+    data = response.json()
+    if not isinstance(data, dict):
+        raise ProviderError("jupiter-v2", "Unexpected order response from Jupiter Swap V2.")
+    if data.get("error") or data.get("errorCode"):
+        raise ProviderError(
+            "jupiter-v2",
+            str(data.get("error") or data.get("errorCode") or "Unknown Swap V2 order error."),
+            details=data,
+        )
+    if "outAmount" not in data:
+        raise ProviderError("jupiter-v2", "Unexpected order response from Jupiter Swap V2.")
+    return data
+
+
 async def build_swap_transaction(
     *,
     user_public_key: str,
@@ -477,6 +530,42 @@ async def execute_ultra_order(
     return data
 
 
+async def execute_swap_v2_order(
+    *,
+    signed_transaction_base64: str,
+    request_id: str,
+    last_valid_block_height: int | str | None = None,
+) -> dict[str, Any]:
+    """Execute a signed Jupiter Swap API V2 order."""
+    client = get_client()
+    body: dict[str, Any] = {
+        "signedTransaction": signed_transaction_base64,
+        "requestId": request_id,
+    }
+    if last_valid_block_height is not None:
+        body["lastValidBlockHeight"] = str(last_valid_block_height)
+    response = await client.post(
+        f"{_swap_v2_base_url()}/execute",
+        json=body,
+        headers={**_headers(), "Content-Type": "application/json"},
+    )
+    if response.status_code != 200:
+        raise ProviderError("jupiter-v2", f"HTTP {response.status_code}: {response.text[:300]}")
+    data = response.json()
+    if not isinstance(data, dict):
+        raise ProviderError("jupiter-v2", "Unexpected execute response from Jupiter Swap V2.")
+    if data.get("error") or data.get("errorCode"):
+        raise ProviderError(
+            "jupiter-v2",
+            str(data.get("error") or data.get("errorCode") or "Unknown Swap V2 execute error."),
+            details=data,
+        )
+    if str(data.get("status") or "").strip().lower() == "failed":
+        message = data.get("error") or data.get("code") or "Swap V2 execute failed."
+        raise ProviderError("jupiter-v2", str(message), details=data)
+    return data
+
+
 async def fetch_prices(
     *,
     mints: list[str],