@agentlayer.tech/wallet 0.1.25 → 0.1.26

package/.openclaw/extensions/agent-wallet/README.md

@@ -17,7 +17,7 @@ In practice this means the agent works through explicit tools for:
 - EVM native balance, ERC-20 balance/metadata, fee-rate, receipt, Velora swap quote/execute, Aave V3 account/reserve/position flows, and transfer flows through the local `wdk-evm-wallet` backend
 - wallet address, balances, and portfolio reads
 - native SOL and SPL token transfers
-- Jupiter swap and price lookup
+- Jupiter swap and price lookup, including Solana swap intent execution that refreshes quotes inside user-approved limits
 - Jupiter Earn read/deposit/withdraw flows
 - Kamino lending read/deposit/withdraw/borrow/repay flows
 - native Solana staking, stake deactivation, and stake withdrawal

package/.openclaw/extensions/agent-wallet/dist/index.js

@@ -76,7 +76,7 @@ function cachePreviewForApproval(userId, toolName, payload) {
   const cacheToolName = approvalPreviewToolName(toolName);
   if (!payload || payload.ok !== true || !payload.data || typeof payload.data !== "object") return;
   const approvalSource = payload.data;
-  if (!["preview", "prepare"].includes(String(approvalSource.mode || ""))) return;
+  if (!["preview", "prepare", "intent_preview"].includes(String(approvalSource.mode || ""))) return;
   if (!approvalSource.confirmation_summary || typeof approvalSource.confirmation_summary !== "object") return;
   pruneApprovalPreviewCache();
   const digest = previewDigest(approvalSource);
@@ -119,7 +119,21 @@ function cachedPreviewForToken(userId, toolName, token) {
   return cached.preview && typeof cached.preview === "object" ? cached.preview : null;
 }
 
-function requiresApprovedPreviewPayload(toolName) {
+function isSolanaSwapIntentPayload(payload) {
+  return (
+    payload &&
+    typeof payload === "object" &&
+    (String(payload.asset_type || "") === "solana-swap-intent" ||
+      String(payload.mode || "") === "intent_preview")
+  );
+}
+
+function isSolanaSwapIntentExecute(params) {
+  return String(params?.mode || "") === "intent_execute";
+}
+
+function requiresApprovedPreviewPayload(toolName, params = null) {
+  if (toolName === "swap_solana_tokens" && isSolanaSwapIntentExecute(params)) return false;
   return PREVIEW_BOUND_SWAP_TOOLS.has(toolName);
 }
 
@@ -536,7 +550,7 @@ async function issueApprovalToken(api, config, userId, toolName, previewPayload)
   if (!summary || typeof summary !== "object") {
     throw new Error(`No confirmation_summary available for ${toolName}.`);
   }
-  const summaryForToken = PREVIEW_BOUND_SWAP_TOOLS.has(toolName)
+  const summaryForToken = PREVIEW_BOUND_SWAP_TOOLS.has(toolName) && !isSolanaSwapIntentPayload(previewPayload)
     ? { ...summary, _preview_digest: previewDigest(previewPayload) }
     : { ...summary };
   const extraArgs = [
@@ -560,7 +574,12 @@ async function issueApprovalToken(api, config, userId, toolName, previewPayload)
 }
 
 async function attachApprovalForExecute(api, config, userId, toolName, effectiveParams) {
-  if (String(effectiveParams.mode || "") !== "execute") return null;
+  if (!["execute", "intent_execute"].includes(String(effectiveParams.mode || ""))) return null;
+  if (toolName === "swap_solana_tokens" && String(effectiveParams.mode || "") === "execute") {
+    throw new Error(
+      "Legacy exact-preview execute is disabled for Solana Jupiter swaps in OpenClaw. Use intent_preview, ask for explicit chat confirmation, then call intent_execute. The intent path binds approval to risk limits instead of a fragile Jupiter quote payload."
+    );
+  }
 
   const cached = latestCachedPreview(userId, toolName);
   if (cached?.preview && cached?.summary) {
@@ -571,14 +590,14 @@ async function attachApprovalForExecute(api, config, userId, toolName, effective
       toolName,
       cached.preview
     );
-    if (requiresApprovedPreviewPayload(toolName)) {
+    if (requiresApprovedPreviewPayload(toolName, effectiveParams)) {
       effectiveParams._approved_preview = cached.preview;
     }
     return cached;
   }
 
   if (
-    requiresApprovedPreviewPayload(toolName) &&
+    requiresApprovedPreviewPayload(toolName, effectiveParams) &&
     typeof effectiveParams.approval_token === "string" &&
     effectiveParams.approval_token.trim() &&
     effectiveParams._approved_preview === undefined
@@ -1312,7 +1331,7 @@ const solanaToolDefinitions = [
   },
   {
     name: "swap_solana_tokens",
-    description: `Preview, prepare, or execute a Solana token swap via Jupiter. Preview or prepare first. After the user explicitly confirms the shown summary in chat, call execute; the OpenClaw plugin handles the internal execution authorization automatically. ${WALLET_TOOL_ONLY_GUIDANCE}`,
+    description: `Preview or execute a Solana token swap via Jupiter. Use intent_preview followed by intent_execute after the user explicitly confirms the intent summary in chat; intent_execute fetches a fresh quote and only executes inside the approved limits. Do not use legacy execute for Solana swaps. The OpenClaw plugin handles internal execution authorization automatically. ${WALLET_TOOL_ONLY_GUIDANCE}`,
     optional: true,
     parameters: {
       type: "object",
@@ -1320,8 +1339,12 @@ const solanaToolDefinitions = [
         input_mint: { type: "string" },
         output_mint: { type: "string" },
         amount: { type: "number" },
-        slippage_bps: { type: "integer" },
-        mode: { type: "string", enum: ["preview", "prepare", "execute"] },
+        slippage_bps: { type: "integer", 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" },
+        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", "intent_preview", "intent_execute"] },
         purpose: { type: "string" },
         user_intent: { type: "boolean" },
       },

package/.openclaw/extensions/agent-wallet/index.ts

@@ -76,7 +76,7 @@ function cachePreviewForApproval(userId, toolName, payload) {
   const cacheToolName = approvalPreviewToolName(toolName);
   if (!payload || payload.ok !== true || !payload.data || typeof payload.data !== "object") return;
   const approvalSource = payload.data;
-  if (!["preview", "prepare"].includes(String(approvalSource.mode || ""))) return;
+  if (!["preview", "prepare", "intent_preview"].includes(String(approvalSource.mode || ""))) return;
   if (!approvalSource.confirmation_summary || typeof approvalSource.confirmation_summary !== "object") return;
   pruneApprovalPreviewCache();
   const digest = previewDigest(approvalSource);
@@ -119,7 +119,21 @@ function cachedPreviewForToken(userId, toolName, token) {
   return cached.preview && typeof cached.preview === "object" ? cached.preview : null;
 }
 
-function requiresApprovedPreviewPayload(toolName) {
+function isSolanaSwapIntentPayload(payload) {
+  return (
+    payload &&
+    typeof payload === "object" &&
+    (String(payload.asset_type || "") === "solana-swap-intent" ||
+      String(payload.mode || "") === "intent_preview")
+  );
+}
+
+function isSolanaSwapIntentExecute(params) {
+  return String(params?.mode || "") === "intent_execute";
+}
+
+function requiresApprovedPreviewPayload(toolName, params = null) {
+  if (toolName === "swap_solana_tokens" && isSolanaSwapIntentExecute(params)) return false;
   return PREVIEW_BOUND_SWAP_TOOLS.has(toolName);
 }
 
@@ -536,7 +550,7 @@ async function issueApprovalToken(api, config, userId, toolName, previewPayload)
   if (!summary || typeof summary !== "object") {
     throw new Error(`No confirmation_summary available for ${toolName}.`);
   }
-  const summaryForToken = PREVIEW_BOUND_SWAP_TOOLS.has(toolName)
+  const summaryForToken = PREVIEW_BOUND_SWAP_TOOLS.has(toolName) && !isSolanaSwapIntentPayload(previewPayload)
     ? { ...summary, _preview_digest: previewDigest(previewPayload) }
     : { ...summary };
   const extraArgs = [
@@ -560,7 +574,12 @@ async function issueApprovalToken(api, config, userId, toolName, previewPayload)
 }
 
 async function attachApprovalForExecute(api, config, userId, toolName, effectiveParams) {
-  if (String(effectiveParams.mode || "") !== "execute") return null;
+  if (!["execute", "intent_execute"].includes(String(effectiveParams.mode || ""))) return null;
+  if (toolName === "swap_solana_tokens" && String(effectiveParams.mode || "") === "execute") {
+    throw new Error(
+      "Legacy exact-preview execute is disabled for Solana Jupiter swaps in OpenClaw. Use intent_preview, ask for explicit chat confirmation, then call intent_execute. The intent path binds approval to risk limits instead of a fragile Jupiter quote payload."
+    );
+  }
 
   const cached = latestCachedPreview(userId, toolName);
   if (cached?.preview && cached?.summary) {
@@ -571,14 +590,14 @@ async function attachApprovalForExecute(api, config, userId, toolName, effective
       toolName,
       cached.preview
     );
-    if (requiresApprovedPreviewPayload(toolName)) {
+    if (requiresApprovedPreviewPayload(toolName, effectiveParams)) {
       effectiveParams._approved_preview = cached.preview;
     }
     return cached;
   }
 
   if (
-    requiresApprovedPreviewPayload(toolName) &&
+    requiresApprovedPreviewPayload(toolName, effectiveParams) &&
     typeof effectiveParams.approval_token === "string" &&
     effectiveParams.approval_token.trim() &&
     effectiveParams._approved_preview === undefined
@@ -1312,7 +1331,7 @@ const solanaToolDefinitions = [
   },
   {
     name: "swap_solana_tokens",
-    description: `Preview, prepare, or execute a Solana token swap via Jupiter. Preview or prepare first. After the user explicitly confirms the shown summary in chat, call execute; the OpenClaw plugin handles the internal execution authorization automatically. ${WALLET_TOOL_ONLY_GUIDANCE}`,
+    description: `Preview or execute a Solana token swap via Jupiter. Use intent_preview followed by intent_execute after the user explicitly confirms the intent summary in chat; intent_execute fetches a fresh quote and only executes inside the approved limits. Do not use legacy execute for Solana swaps. The OpenClaw plugin handles internal execution authorization automatically. ${WALLET_TOOL_ONLY_GUIDANCE}`,
     optional: true,
     parameters: {
       type: "object",
@@ -1320,8 +1339,12 @@ const solanaToolDefinitions = [
         input_mint: { type: "string" },
         output_mint: { type: "string" },
         amount: { type: "number" },
-        slippage_bps: { type: "integer" },
-        mode: { type: "string", enum: ["preview", "prepare", "execute"] },
+        slippage_bps: { type: "integer", 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" },
+        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", "intent_preview", "intent_execute"] },
         purpose: { type: "string" },
         user_intent: { type: "boolean" },
       },

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`

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",
@@ -5248,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)
@@ -5262,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(
@@ -5284,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(
@@ -5305,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,

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],

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

@@ -3,6 +3,7 @@
 from __future__ import annotations
 
 from abc import ABC, abstractmethod
+import time
 from dataclasses import asdict, dataclass, field
 from typing import Any
 
@@ -731,16 +732,74 @@ class AgentWalletBackend(ABC):
         input_mint: str,
         output_mint: str,
         amount_ui: float,
-        slippage_bps: int = 50,
+        slippage_bps: int = 300,
     ) -> dict[str, Any]:
         raise WalletBackendError(f"{self.name} does not support swap previews.")
 
+    async def preview_swap_intent(
+        self,
+        input_mint: str,
+        output_mint: str,
+        amount_ui: float,
+        slippage_bps: int = 300,
+        minimum_output_amount_raw: int | None = None,
+        max_fee_lamports: int | None = None,
+        valid_for_seconds: int = 30,
+        max_attempts: int = 2,
+    ) -> dict[str, Any]:
+        preview = await self.preview_swap(
+            input_mint=input_mint,
+            output_mint=output_mint,
+            amount_ui=amount_ui,
+            slippage_bps=slippage_bps,
+        )
+        fee_summary = preview.get("fee_summary") if isinstance(preview.get("fee_summary"), dict) else {}
+        network_fee_lamports = fee_summary.get("network_fee_lamports")
+        if max_fee_lamports is None and isinstance(network_fee_lamports, int):
+            max_fee_lamports = max(network_fee_lamports * 3, network_fee_lamports + 100_000)
+        resolved_min_raw = minimum_output_amount_raw
+        if resolved_min_raw is None and isinstance(preview.get("minimum_output_amount_raw"), int):
+            resolved_min_raw = int(preview["minimum_output_amount_raw"])
+        output_decimals = preview.get("output_decimals")
+        minimum_output_amount_ui = preview.get("minimum_output_amount_ui")
+        if resolved_min_raw is not None and isinstance(output_decimals, int):
+            minimum_output_amount_ui = int(resolved_min_raw) / (10**output_decimals)
+        return {
+            "chain": preview.get("chain", "solana"),
+            "network": preview.get("network", getattr(self, "network", "unknown")),
+            "mode": "intent_preview",
+            "asset_type": "solana-swap-intent",
+            "owner": preview.get("owner"),
+            "input_mint": preview.get("input_mint", input_mint),
+            "output_mint": preview.get("output_mint", output_mint),
+            "input_amount_ui": preview.get("input_amount_ui", amount_ui),
+            "input_amount_raw": preview.get("input_amount_raw"),
+            "minimum_output_amount_raw": resolved_min_raw,
+            "minimum_output_amount_ui": minimum_output_amount_ui,
+            "indicative_output_amount_ui": preview.get("estimated_output_amount_ui"),
+            "indicative_output_amount_raw": preview.get("estimated_output_amount_raw"),
+            "max_slippage_bps": slippage_bps,
+            "slippage_bps": slippage_bps,
+            "max_fee_lamports": max_fee_lamports,
+            "valid_for_seconds": valid_for_seconds,
+            "valid_until_epoch_seconds": int(time.time()) + valid_for_seconds,
+            "max_attempts": max_attempts,
+            "allowed_providers": ["jupiter-ultra", "jupiter-metis"],
+            "recipient_policy": "owner-only",
+            "spend_policy": "exact-input",
+            "indicative_swap_provider": preview.get("swap_provider"),
+            "indicative_fee_summary": fee_summary,
+            "can_send": preview.get("can_send"),
+            "sign_only": preview.get("sign_only"),
+            "source": "swap-intent",
+        }
+
     async def prepare_swap(
         self,
         input_mint: str,
         output_mint: str,
         amount_ui: float,
-        slippage_bps: int = 50,
+        slippage_bps: int = 300,
     ) -> dict[str, Any]:
         raise WalletBackendError(f"{self.name} does not support swap preparation.")
 
@@ -752,7 +811,7 @@ class AgentWalletBackend(ABC):
             input_mint=str(preview["input_mint"]),
             output_mint=str(preview["output_mint"]),
             amount_ui=float(preview["input_amount_ui"]),
-            slippage_bps=int(preview.get("slippage_bps") or 50),
+            slippage_bps=int(preview.get("slippage_bps") or 300),
         )
 
     async def execute_swap(
@@ -760,7 +819,7 @@ class AgentWalletBackend(ABC):
         input_mint: str,
         output_mint: str,
         amount_ui: float,
-        slippage_bps: int = 50,
+        slippage_bps: int = 300,
     ) -> dict[str, Any]:
         raise WalletBackendError(f"{self.name} does not support swaps.")
 
@@ -772,8 +831,55 @@ class AgentWalletBackend(ABC):
             input_mint=str(preview["input_mint"]),
             output_mint=str(preview["output_mint"]),
             amount_ui=float(preview["input_amount_ui"]),
-            slippage_bps=int(preview.get("slippage_bps") or 50),
+            slippage_bps=int(preview.get("slippage_bps") or 300),
+        )
+
+    async def execute_swap_intent(
+        self,
+        *,
+        input_mint: str,
+        output_mint: str,
+        amount_ui: float,
+        slippage_bps: int = 300,
+        minimum_output_amount_raw: int | None = None,
+        max_fee_lamports: int | None = None,
+        valid_until_epoch_seconds: int | None = None,
+        max_attempts: int = 2,
+    ) -> dict[str, Any]:
+        if valid_until_epoch_seconds is not None and int(time.time()) > int(valid_until_epoch_seconds):
+            raise WalletBackendError("Approved swap intent has expired. Create a fresh intent preview.")
+        preview = await self.preview_swap(
+            input_mint=input_mint,
+            output_mint=output_mint,
+            amount_ui=amount_ui,
+            slippage_bps=slippage_bps,
         )
+        output_raw = preview.get("estimated_output_amount_raw")
+        if (
+            minimum_output_amount_raw is not None
+            and isinstance(output_raw, int)
+            and output_raw < int(minimum_output_amount_raw)
+        ):
+            raise WalletBackendError(
+                "Fresh swap quote is below the approved minimum output. Funds were not moved."
+            )
+        fee_summary = preview.get("fee_summary") if isinstance(preview.get("fee_summary"), dict) else {}
+        network_fee_lamports = fee_summary.get("network_fee_lamports")
+        if (
+            max_fee_lamports is not None
+            and isinstance(network_fee_lamports, int)
+            and network_fee_lamports > int(max_fee_lamports)
+        ):
+            raise WalletBackendError("Fresh swap fee exceeds the approved fee limit. Funds were not moved.")
+        result = await self.execute_swap_from_preview(preview)
+        result["intent_execution"] = {
+            "approved_minimum_output_amount_raw": minimum_output_amount_raw,
+            "approved_max_fee_lamports": max_fee_lamports,
+            "fresh_quote_used": True,
+            "attempt_count": 1,
+            "max_attempts": max_attempts,
+        }
+        return result
 
     async def get_bags_claimable_positions(
         self,

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

@@ -7,6 +7,7 @@ import base64
 import binascii
 import hashlib
 import json
+import time
 from decimal import Decimal, InvalidOperation
 from typing import Any
 
@@ -48,6 +49,8 @@ TOKEN_2022_PROGRAM_ID = "TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb"
 NATIVE_SOL_MINT = "So11111111111111111111111111111111111111112"
 STAKE_PROGRAM_ID = "Stake11111111111111111111111111111111111111"
 HOUDINI_PRIVATE_OUTPUT_DRIFT_BPS = 600
+SOLANA_SWAP_DEFAULT_SLIPPAGE_BPS = 300
+SOLANA_SWAP_INTENT_DEFAULT_MAX_FEE_LAMPORTS = 6_000_000
 
 
 def _load_signing_key():
@@ -2062,6 +2065,29 @@ class SolanaWalletBackend(AgentWalletBackend):
             parts.append(f"route fee {route_fee_bps} bps (already reflected in quoted output)")
         return "; ".join(parts)
 
+    def _swap_fee_lamports(self, payload: dict[str, Any]) -> int | None:
+        fee_summary = payload.get("fee_summary")
+        if isinstance(fee_summary, dict):
+            network_fee = _coerce_int(fee_summary.get("network_fee_lamports"))
+            if network_fee is not None:
+                return network_fee
+        return None
+
+    def _default_swap_intent_max_fee_lamports(self, fee_summary: dict[str, Any]) -> int:
+        estimated_fee = _coerce_int(fee_summary.get("network_fee_lamports")) or 0
+        return max(
+            estimated_fee * 3,
+            estimated_fee + 100_000,
+            SOLANA_SWAP_INTENT_DEFAULT_MAX_FEE_LAMPORTS,
+        )
+
+    def _swap_minimum_output_floor(self, *, out_amount_raw: int, slippage_bps: int) -> int:
+        if out_amount_raw <= 0:
+            return 0
+        if slippage_bps <= 0:
+            raise WalletBackendError("slippage_bps must be greater than zero.")
+        return max(1, (out_amount_raw * max(0, 10_000 - slippage_bps)) // 10_000)
+
     def _require_mainnet_bags(self, feature: str) -> None:
         if self.network != "mainnet":
             raise WalletBackendError(f"{feature} is only enabled for Solana mainnet.")
@@ -5426,7 +5452,8 @@ class SolanaWalletBackend(AgentWalletBackend):
         input_mint: str,
         output_mint: str,
         amount_ui: float,
-        slippage_bps: int = 50,
+        slippage_bps: int = SOLANA_SWAP_DEFAULT_SLIPPAGE_BPS,
+        exclude_routers: list[str] | None = None,
     ) -> dict[str, Any]:
         if self.network != "mainnet":
             raise WalletBackendError("Provider-routed swaps are only enabled for Solana mainnet.")
@@ -5447,29 +5474,38 @@ class SolanaWalletBackend(AgentWalletBackend):
             raise WalletBackendError("amount is too small for the input token decimals.")
 
         sender = await self.get_address()
-        quote_source = "jupiter-ultra"
+        quote_source = "jupiter-v2-order"
         try:
-            quote = await jupiter.fetch_ultra_order(
+            quote = await jupiter.fetch_swap_v2_order(
                 input_mint=input_mint,
                 output_mint=output_mint,
                 amount_raw=raw_amount,
                 taker=sender,
-                slippage_bps=slippage_bps,
+                exclude_routers=exclude_routers,
             )
         except ProviderError:
-            quote = await jupiter.fetch_quote(
-                input_mint=input_mint,
-                output_mint=output_mint,
-                amount_raw=raw_amount,
-                slippage_bps=slippage_bps,
-            )
-            quote_source = "jupiter-metis"
+            quote_source = "jupiter-ultra"
+            try:
+                quote = await jupiter.fetch_ultra_order(
+                    input_mint=input_mint,
+                    output_mint=output_mint,
+                    amount_raw=raw_amount,
+                    taker=sender,
+                    slippage_bps=slippage_bps,
+                )
+            except ProviderError:
+                quote = await jupiter.fetch_quote(
+                    input_mint=input_mint,
+                    output_mint=output_mint,
+                    amount_raw=raw_amount,
+                    slippage_bps=slippage_bps,
+                )
+                quote_source = "jupiter-metis"
 
         out_amount_raw = int(quote.get("outAmount") or 0)
-        other_threshold_raw = int(
-            quote.get("otherAmountThreshold")
-            or quote.get("minOutAmount")
-            or 0
+        other_threshold_raw = self._swap_minimum_output_floor(
+            out_amount_raw=out_amount_raw,
+            slippage_bps=slippage_bps,
         )
         fee_summary = self._build_swap_fee_summary(
             swap_provider=quote_source,
@@ -5505,12 +5541,115 @@ class SolanaWalletBackend(AgentWalletBackend):
             "source": quote_source,
         }
 
+    async def preview_swap_intent(
+        self,
+        input_mint: str,
+        output_mint: str,
+        amount_ui: float,
+        slippage_bps: int = SOLANA_SWAP_DEFAULT_SLIPPAGE_BPS,
+        minimum_output_amount_raw: int | None = None,
+        max_fee_lamports: int | None = None,
+        valid_for_seconds: int = 120,
+        max_attempts: int = 3,
+    ) -> dict[str, Any]:
+        if valid_for_seconds <= 0 or valid_for_seconds > 120:
+            raise WalletBackendError("valid_for_seconds must be between 1 and 120.")
+        if max_attempts <= 0 or max_attempts > 5:
+            raise WalletBackendError("max_attempts must be between 1 and 5.")
+        slippage_bps = max(int(slippage_bps), SOLANA_SWAP_DEFAULT_SLIPPAGE_BPS)
+        max_attempts = max(int(max_attempts), 3)
+
+        indicative = await self.preview_swap(
+            input_mint=input_mint,
+            output_mint=output_mint,
+            amount_ui=amount_ui,
+            slippage_bps=slippage_bps,
+        )
+        indicative_output_raw = int(indicative.get("estimated_output_amount_raw") or 0)
+        slippage_floor_raw = self._swap_minimum_output_floor(
+            out_amount_raw=indicative_output_raw,
+            slippage_bps=slippage_bps,
+        )
+        requested_min_output_raw = (
+            int(minimum_output_amount_raw)
+            if minimum_output_amount_raw is not None
+            else None
+        )
+        if requested_min_output_raw is not None:
+            min_output_raw = min(requested_min_output_raw, slippage_floor_raw)
+            minimum_output_policy = (
+                "explicit_clamped_to_slippage_floor"
+                if requested_min_output_raw > slippage_floor_raw
+                else "explicit"
+            )
+        else:
+            min_output_raw = slippage_floor_raw
+            minimum_output_policy = "slippage_floor"
+        if min_output_raw <= 0:
+            raise WalletBackendError("minimum_output_amount_raw could not be derived from the indicative quote.")
+        output_decimals = int(indicative.get("output_decimals") or 0)
+        min_output_ui = min_output_raw / (10**output_decimals)
+
+        fee_summary = (
+            indicative.get("fee_summary")
+            if isinstance(indicative.get("fee_summary"), dict)
+            else {}
+        )
+        fee_limit = (
+            int(max_fee_lamports)
+            if max_fee_lamports is not None
+            else self._default_swap_intent_max_fee_lamports(fee_summary)
+        )
+        if fee_limit < 0:
+            raise WalletBackendError("max_fee_lamports must be non-negative.")
+
+        return {
+            "chain": "solana",
+            "network": self.network,
+            "mode": "intent_preview",
+            "asset_type": "solana-swap-intent",
+            "owner": indicative.get("owner"),
+            "input_mint": indicative["input_mint"],
+            "output_mint": indicative["output_mint"],
+            "input_amount_ui": indicative["input_amount_ui"],
+            "input_amount_raw": indicative["input_amount_raw"],
+            "input_decimals": indicative.get("input_decimals"),
+            "output_decimals": indicative.get("output_decimals"),
+            "indicative_output_amount_ui": indicative.get("estimated_output_amount_ui"),
+            "indicative_output_amount_raw": indicative.get("estimated_output_amount_raw"),
+            "minimum_output_amount_ui": min_output_ui,
+            "minimum_output_amount_raw": min_output_raw,
+            "requested_minimum_output_amount_raw": requested_min_output_raw,
+            "minimum_output_policy": minimum_output_policy,
+            "max_slippage_bps": slippage_bps,
+            "slippage_bps": slippage_bps,
+            "max_fee_lamports": fee_limit,
+            "max_fee_sol": fee_limit / solana_rpc.LAMPORTS_PER_SOL,
+            "valid_for_seconds": valid_for_seconds,
+            "valid_until_epoch_seconds": int(time.time()) + valid_for_seconds,
+            "max_attempts": max_attempts,
+            "allowed_providers": ["jupiter-v2-order", "jupiter-ultra", "jupiter-metis"],
+            "recipient_policy": "owner-only",
+            "spend_policy": "exact-input",
+            "indicative_swap_provider": indicative.get("swap_provider"),
+            "indicative_price_impact_pct": indicative.get("price_impact_pct"),
+            "indicative_route_plan": indicative.get("route_plan", []),
+            "indicative_fee_summary": fee_summary,
+            "intent_note": (
+                "This is an intent approval preview. Execute will fetch a fresh quote and "
+                "only sign/send if it remains inside these approved limits."
+            ),
+            "can_send": self.get_capabilities().can_send_transaction,
+            "sign_only": self.sign_only,
+            "source": "swap-intent",
+        }
+
     async def execute_swap(
         self,
         input_mint: str,
         output_mint: str,
         amount_ui: float,
-        slippage_bps: int = 50,
+        slippage_bps: int = SOLANA_SWAP_DEFAULT_SLIPPAGE_BPS,
     ) -> dict[str, Any]:
         preview = await self.preview_swap(
             input_mint=input_mint,
@@ -5520,17 +5659,23 @@ class SolanaWalletBackend(AgentWalletBackend):
         )
         return await self.execute_swap_from_preview(preview)
 
-    async def execute_swap_from_preview(
+    async def _submit_prepared_swap(
         self,
-        preview: dict[str, Any],
+        prepared: dict[str, Any],
     ) -> dict[str, Any]:
-        prepared = await self.prepare_swap_from_preview(preview)
         if self.sign_only:
             raise WalletBackendError(
                 "This wallet backend is in sign-only mode. Disable sign_only to broadcast transactions."
             )
 
-        if prepared.get("swap_provider") == "jupiter-ultra":
+        if prepared.get("swap_provider") == "jupiter-v2-order":
+            submitted = await jupiter.execute_swap_v2_order(
+                signed_transaction_base64=str(prepared["transaction_base64"]),
+                request_id=str(prepared["request_id"]),
+                last_valid_block_height=_coerce_int(prepared.get("last_valid_block_height")),
+            )
+            onchain_signature = submitted.get("signature") or submitted.get("txid")
+        elif prepared.get("swap_provider") == "jupiter-ultra":
             submitted = await jupiter.execute_ultra_order(
                 signed_transaction_base64=str(prepared["transaction_base64"]),
                 request_id=str(prepared["request_id"]),
@@ -5583,12 +5728,132 @@ class SolanaWalletBackend(AgentWalletBackend):
             "source": prepared.get("swap_provider") or "jupiter-metis",
         }
 
+    async def execute_swap_from_preview(
+        self,
+        preview: dict[str, Any],
+    ) -> dict[str, Any]:
+        prepared = await self.prepare_swap_from_preview(preview)
+        return await self._submit_prepared_swap(prepared)
+
+    async def execute_swap_intent(
+        self,
+        *,
+        input_mint: str,
+        output_mint: str,
+        amount_ui: float,
+        slippage_bps: int = SOLANA_SWAP_DEFAULT_SLIPPAGE_BPS,
+        minimum_output_amount_raw: int | None = None,
+        max_fee_lamports: int | None = None,
+        valid_until_epoch_seconds: int | None = None,
+        max_attempts: int = 3,
+    ) -> dict[str, Any]:
+        if valid_until_epoch_seconds is not None and int(time.time()) > int(valid_until_epoch_seconds):
+            raise WalletBackendError("Approved swap intent has expired. Create a fresh intent preview.")
+        if max_attempts <= 0 or max_attempts > 5:
+            raise WalletBackendError("max_attempts must be between 1 and 5.")
+        slippage_bps = max(int(slippage_bps), SOLANA_SWAP_DEFAULT_SLIPPAGE_BPS)
+        max_attempts = max(int(max_attempts), 3)
+
+        attempts: list[dict[str, Any]] = []
+        last_error: str | None = None
+        for attempt_index in range(max_attempts):
+            if valid_until_epoch_seconds is not None and int(time.time()) > int(valid_until_epoch_seconds):
+                break
+            try:
+                exclude_routers = ["jupiterz"] if attempt_index > 0 else None
+                preview = await self.preview_swap(
+                    input_mint=input_mint,
+                    output_mint=output_mint,
+                    amount_ui=amount_ui,
+                    slippage_bps=slippage_bps,
+                    exclude_routers=exclude_routers,
+                )
+                estimated_output_raw = int(preview.get("estimated_output_amount_raw") or 0)
+                if (
+                    minimum_output_amount_raw is not None
+                    and estimated_output_raw < int(minimum_output_amount_raw)
+                ):
+                    attempts.append(
+                        {
+                            "attempt": attempt_index + 1,
+                            "swap_provider": preview.get("swap_provider"),
+                            "rejected": "quote_below_minimum_output",
+                            "estimated_output_amount_raw": estimated_output_raw,
+                            "minimum_output_amount_raw": int(minimum_output_amount_raw),
+                        }
+                    )
+                    last_error = "Fresh swap quote is below the approved minimum output."
+                    continue
+
+                prepared = await self.prepare_swap_from_preview(preview)
+                prepared_fee = self._swap_fee_lamports(prepared)
+                if (
+                    max_fee_lamports is not None
+                    and prepared_fee is not None
+                    and prepared_fee > int(max_fee_lamports)
+                ):
+                    attempts.append(
+                        {
+                            "attempt": attempt_index + 1,
+                            "swap_provider": prepared.get("swap_provider"),
+                            "rejected": "fee_above_limit",
+                            "fee_lamports": prepared_fee,
+                            "max_fee_lamports": int(max_fee_lamports),
+                        }
+                    )
+                    last_error = "Fresh swap fee exceeds the approved fee limit."
+                    continue
+
+                result = await self._submit_prepared_swap(prepared)
+                result["intent_execution"] = {
+                    "approved_minimum_output_amount_raw": minimum_output_amount_raw,
+                    "approved_max_fee_lamports": max_fee_lamports,
+                    "fresh_quote_used": True,
+                    "attempt_count": attempt_index + 1,
+                    "max_attempts": max_attempts,
+                    "attempts": attempts
+                    + [
+                        {
+                            "attempt": attempt_index + 1,
+                            "swap_provider": prepared.get("swap_provider"),
+                            "status": "submitted",
+                        }
+                    ],
+                }
+                return result
+            except (WalletBackendError, ProviderError) as exc:
+                last_error = str(exc)
+                attempts.append(
+                    {
+                        "attempt": attempt_index + 1,
+                        "rejected": "execution_error",
+                        "error": str(exc),
+                    }
+                )
+                if "sign-only mode" in str(exc).lower():
+                    break
+            if attempt_index + 1 < max_attempts:
+                await asyncio.sleep(min(0.5 * (attempt_index + 1), 1.5))
+
+        reason_suffix = f" Last reason: {last_error}" if last_error else ""
+        raise WalletBackendError(
+            "Solana swap intent execution failed within the approved limits. Funds were not moved."
+            + reason_suffix,
+            details={
+                "reason": last_error,
+                "attempts": attempts,
+                "minimum_output_amount_raw": minimum_output_amount_raw,
+                "max_fee_lamports": max_fee_lamports,
+                "max_attempts": max_attempts,
+            },
+        )
+
     async def prepare_swap(
         self,
         input_mint: str,
         output_mint: str,
         amount_ui: float,
-        slippage_bps: int = 50,
+        slippage_bps: int = SOLANA_SWAP_DEFAULT_SLIPPAGE_BPS,
     ) -> dict[str, Any]:
         preview = await self.preview_swap(
             input_mint=input_mint,
@@ -5629,13 +5894,23 @@ class SolanaWalletBackend(AgentWalletBackend):
 
         swap_provider = str(preview.get("swap_provider") or "jupiter-metis")
         request_id = None
-        if swap_provider == "jupiter-ultra":
+        if swap_provider in {"jupiter-v2-order", "jupiter-ultra"}:
             swap_build = preview["quote_response"]
             unsigned_transaction = VersionedTransaction.from_bytes(
                 base64.b64decode(str(swap_build["transaction"]))
             )
             request_id = swap_build.get("requestId")
-            last_valid_block_height = swap_build.get("expireAt")
+            blockhash_metadata = swap_build.get("blockhashWithMetadata")
+            last_valid_block_height = (
+                blockhash_metadata.get("lastValidBlockHeight")
+                if isinstance(blockhash_metadata, dict)
+                else None
+            )
+            if last_valid_block_height is None:
+                last_valid_block_height = (
+                    swap_build.get("lastValidBlockHeight")
+                    or swap_build.get("expireAt")
+                )
             prioritization_fee_lamports = swap_build.get("prioritizationFeeLamports")
             compute_unit_limit = swap_build.get("computeUnitLimit")
         else:

package/agent-wallet/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "openclaw-agent-wallet"
-version = "0.1.25"
+version = "0.1.26"
 description = "Plugin-friendly wallet backend for OpenClaw agents"
 requires-python = ">=3.10"
 dependencies = [

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

@@ -12,7 +12,7 @@ Use this skill before calling OpenClaw wallet tools. It is the routing guide for
 1. Start with `get_wallet_capabilities` when the active chain, signing support, or available tools are unclear.
 2. Use `get_wallet_address` before asking for deposits or confirming a recipient/source wallet.
 3. Use `get_wallet_balance` before spending, swapping, bridging, staking, lending, or claiming.
-4. Use `preview` first for every write action. Use `prepare` only after explicit user intent. In OpenClaw, use `execute` only after the user explicitly confirms the shown summary in chat; do not ask the user for `/approve`, buttons, popups, or a manual token.
+4. Use `preview` first for every write action. For Solana Jupiter swaps, prefer `intent_preview` then `intent_execute` after explicit chat confirmation so execution can refresh the quote inside approved limits. Solana swap intents are normalized by the backend to at least 300 bps slippage, 120 seconds validity, and 3 fresh execution attempts; do not pass a hand-tightened `minimum_output_amount_raw` unless the user explicitly set that floor. Use `prepare` only after explicit user intent. In OpenClaw, use `execute` only after the user explicitly confirms the shown summary in chat; do not ask the user for `/approve`, buttons, popups, or a manual token.
 5. `prepare` returns an execution plan only; it must not return signed transaction bytes.
 6. On mainnet, restate the network and material terms before `execute`; the OpenClaw plugin handles the internal execution authorization after chat confirmation.
 7. If backend is `sign_only`, do not execute; use `prepare` and state that nothing was broadcast.
@@ -76,7 +76,11 @@ Use this skill before calling OpenClaw wallet tools. It is the routing guide for
 ## Swap Commands
 
 - Solana same-chain Jupiter swap: `swap_solana_tokens`
-  - Params: `input_mint`, `output_mint`, `amount` in UI units, optional `slippage_bps`, `mode`, `purpose`.
+  - Params: `input_mint`, `output_mint`, `amount` in UI units, optional `slippage_bps`, `minimum_output_amount_raw`, `max_fee_lamports`, `valid_for_seconds`, `max_attempts`, `mode`, `purpose`.
+  - Prefer `mode=intent_preview`, show the intent limits to the user, then after chat confirmation call `mode=intent_execute` with the same semantic params. This confirms risk limits, not a stale quote fingerprint.
+  - Default Solana swap slippage is 300 bps (3%). The backend computes the approved minimum output from the indicative output and slippage, not from a strict RFQ threshold.
+  - The primary execution path uses Jupiter Swap API V2 `/order` + `/execute`; if a JupiterZ/RFQ route fails, the backend retries with a non-JupiterZ route when possible.
+  - Do not use legacy `execute` for Solana Jupiter swaps in OpenClaw; exact quote-bound approval is too fragile for active markets.
   - Use for SOL<->SPL or SPL<->SPL on Solana. Do not use LI.FI for Solana-only swaps.
 - EVM same-chain Velora swap: `swap_evm_tokens`
   - Params: `token_in`, `token_out`, `amount_in_raw` base-unit string, `mode`, `purpose`, optional `network`.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agentlayer.tech/wallet",
-  "version": "0.1.25",
+  "version": "0.1.26",
   "description": "NPM installer for the OpenClaw Agent Wallet local runtime.",
   "type": "module",
   "repository": {
@@ -74,4 +74,4 @@
     "evm"
   ],
   "license": "SEE LICENSE IN LICENSE"
-}
+}