@agentlayer.tech/wallet 0.1.25 → 0.1.27

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.")
@@ -3739,19 +3765,7 @@ class SolanaWalletBackend(AgentWalletBackend):
         keypair = Keypair.from_bytes(self.signer.export_keypair_bytes())
         try:
             unsigned_transaction = VersionedTransaction.from_bytes(raw_transaction)
-            signature = keypair.sign_message(to_bytes_versioned(unsigned_transaction.message))
-            signatures = list(unsigned_transaction.signatures)
-            if wallet_signer_index >= len(signatures):
-                raise WalletBackendError(
-                    "Provider transaction signer layout is incompatible with local signing."
-                )
-            signatures[wallet_signer_index] = signature
-            signed_transaction = VersionedTransaction.populate(
-                unsigned_transaction.message,
-                signatures,
-            )
-            return encode_transaction_base64(bytes(signed_transaction))
-        except Exception:
+        except (TypeError, ValueError):
             unsigned_transaction = Transaction.from_bytes(raw_transaction)
             signatures = list(unsigned_transaction.signatures)
             if wallet_signer_index >= len(signatures):
@@ -3763,6 +3777,18 @@ class SolanaWalletBackend(AgentWalletBackend):
                 unsigned_transaction.message.recent_blockhash,
             )
             return encode_transaction_base64(bytes(unsigned_transaction))
+        signature = keypair.sign_message(to_bytes_versioned(unsigned_transaction.message))
+        signatures = list(unsigned_transaction.signatures)
+        if wallet_signer_index >= len(signatures):
+            raise WalletBackendError(
+                "Provider transaction signer layout is incompatible with local signing."
+            )
+        signatures[wallet_signer_index] = signature
+        signed_transaction = VersionedTransaction.populate(
+            unsigned_transaction.message,
+            signatures,
+        )
+        return encode_transaction_base64(bytes(signed_transaction))
 
     async def _prepare_jupiter_lend_transaction(
         self,
@@ -3821,9 +3847,11 @@ class SolanaWalletBackend(AgentWalletBackend):
             raise WalletBackendError(
                 "This wallet backend is in sign-only mode. Disable sign_only to broadcast transactions."
             )
+        kamino_verified = bool((prepared.get("kamino_safety") or {}).get("verified"))
         submitted = await solana_rpc.send_transaction(
             transaction_base64=str(prepared["transaction_base64"]),
             rpc_url=self.rpc_urls,
+            skip_preflight=source == "kamino" and kamino_verified,
         )
         signature = submitted.get("signature")
         status = None
@@ -3832,6 +3860,8 @@ class SolanaWalletBackend(AgentWalletBackend):
             status = await solana_rpc.wait_for_confirmation(
                 signature=signature,
                 rpc_url=self.rpc_urls,
+                timeout_seconds=60.0 if source == "kamino" else 20.0,
+                poll_interval_seconds=2.0 if source == "kamino" else 1.0,
             )
             confirmed = status is not None
         return {
@@ -3849,6 +3879,8 @@ class SolanaWalletBackend(AgentWalletBackend):
             "slot": status.get("slot") if status else None,
             "sign_only": self.sign_only,
             "source": source,
+            "simulation": prepared.get("simulation"),
+            "kamino_safety": prepared.get("kamino_safety"),
         }
 
     async def _execute_prepared_jupiter_lend_transaction(self, prepared: dict[str, Any]) -> dict[str, Any]:
@@ -3899,6 +3931,37 @@ class SolanaWalletBackend(AgentWalletBackend):
                 matches.append(item)
         return matches
 
+    def _resolve_kamino_obligation_selection(
+        self,
+        *,
+        obligations: list[Any],
+        obligation_address: str | None,
+        action: str,
+    ) -> tuple[list[dict[str, Any]], dict[str, Any] | None]:
+        candidates = [item for item in obligations if isinstance(item, dict)]
+        requested = str(obligation_address or "").strip()
+        if requested:
+            requested = validate_solana_address(requested)
+            for item in candidates:
+                if (
+                    _kamino_entry_address(
+                        item,
+                        "obligationAddress",
+                        "obligation",
+                        "address",
+                        "pubkey",
+                        "loanId",
+                    )
+                    == requested
+                ):
+                    return candidates, item
+            raise WalletBackendError(
+                f"Requested obligation_address is not available for Kamino {action} in the selected market."
+            )
+        if len(candidates) == 1:
+            return candidates, candidates[0]
+        return candidates, None
+
     async def _prepare_kamino_lend_transaction(
         self,
         *,
@@ -3907,6 +3970,7 @@ class SolanaWalletBackend(AgentWalletBackend):
         market: str,
         reserve: str,
         amount_ui: str,
+        obligation_address: str | None = None,
     ) -> dict[str, Any]:
         if not self.signer:
             raise WalletBackendError("Solana signer is not configured.")
@@ -3927,12 +3991,49 @@ class SolanaWalletBackend(AgentWalletBackend):
             market_address=market,
             reserve_address=reserve,
             action=f"Kamino {action}",
+            obligation_address=obligation_address,
             loaded_addresses=loaded_addresses,
         )
         signed_transaction_base64 = await self._sign_versioned_provider_transaction(
             transaction_base64=transaction_base64,
             wallet_signer_index=int(verification.get("wallet_signer_index") or 0),
         )
+        simulation_value: dict[str, Any] | None = None
+        kamino_safety: dict[str, Any]
+        try:
+            simulation = await solana_rpc.simulate_transaction(
+                transaction_base64=signed_transaction_base64,
+                rpc_url=self.rpc_urls,
+                commitment=self.commitment,
+            )
+            simulation_value = (
+                simulation.get("value") if isinstance(simulation.get("value"), dict) else {}
+            )
+            if isinstance(simulation_value, dict) and simulation_value.get("err") is not None:
+                raise WalletBackendError(
+                    f"Kamino {action} transaction simulation failed.",
+                    code="kamino_simulation_failed",
+                    details={
+                        "simulation": simulation_value,
+                        "action": action,
+                        "market": market,
+                        "reserve": reserve,
+                    },
+                )
+            kamino_safety = {
+                "verified": True,
+                "simulation_unavailable": False,
+            }
+        except ProviderError as exc:
+            kamino_safety = {
+                "verified": False,
+                "simulation_unavailable": True,
+                "warning": (
+                    "Kamino simulation could not be completed via the configured Solana RPC. "
+                    "Proceeding with structural provider verification only."
+                ),
+                "error": str(exc),
+            }
         return {
             "chain": "solana",
             "network": self.network,
@@ -3941,6 +4042,7 @@ class SolanaWalletBackend(AgentWalletBackend):
             "owner": owner,
             "market": market,
             "reserve": reserve,
+            "obligation_address": obligation_address,
             "amount_ui": amount_ui,
             "transaction_base64": signed_transaction_base64,
             "transaction_encoding": "base64",
@@ -3949,15 +4051,30 @@ class SolanaWalletBackend(AgentWalletBackend):
             "broadcasted": False,
             "confirmed": False,
             "verification": verification,
+            "simulation": simulation_value,
+            "kamino_safety": kamino_safety,
             "sign_only": self.sign_only,
             "source": "kamino",
         }
 
+    def _kamino_preview_from_approved(
+        self,
+        approved_preview: dict[str, Any] | None,
+        *,
+        asset_type: str,
+    ) -> dict[str, Any] | None:
+        if not isinstance(approved_preview, dict):
+            return None
+        if str(approved_preview.get("asset_type") or "").strip() != asset_type:
+            return None
+        return dict(approved_preview)
+
     async def preview_kamino_lend_deposit(
         self,
         market: str,
         reserve: str,
         amount_ui: str,
+        obligation_address: str | None = None,
     ) -> dict[str, Any]:
         self._require_mainnet_kamino("Kamino lending")
         owner = await self.get_address()
@@ -3995,8 +4112,13 @@ class SolanaWalletBackend(AgentWalletBackend):
         market: str,
         reserve: str,
         amount_ui: str,
+        obligation_address: str | None = None,
+        approved_preview: dict[str, Any] | None = None,
     ) -> dict[str, Any]:
-        preview = await self.preview_kamino_lend_deposit(
+        preview = self._kamino_preview_from_approved(
+            approved_preview,
+            asset_type="kamino-lend-deposit",
+        ) or await self.preview_kamino_lend_deposit(
             market=market,
             reserve=reserve,
             amount_ui=amount_ui,
@@ -4023,11 +4145,14 @@ class SolanaWalletBackend(AgentWalletBackend):
         market: str,
         reserve: str,
         amount_ui: str,
+        obligation_address: str | None = None,
+        approved_preview: dict[str, Any] | None = None,
     ) -> dict[str, Any]:
         prepared = await self.prepare_kamino_lend_deposit(
             market=market,
             reserve=reserve,
             amount_ui=amount_ui,
+            approved_preview=approved_preview,
         )
         result = await self._execute_prepared_provider_transaction(prepared, source="kamino")
         result["build_response"] = prepared.get("build_response")
@@ -4038,6 +4163,7 @@ class SolanaWalletBackend(AgentWalletBackend):
         market: str,
         reserve: str,
         amount_ui: str,
+        obligation_address: str | None = None,
     ) -> dict[str, Any]:
         self._require_mainnet_kamino("Kamino lending")
         owner = await self.get_address()
@@ -4062,6 +4188,19 @@ class SolanaWalletBackend(AgentWalletBackend):
         )
         if not obligation_matches:
             raise WalletBackendError("No Kamino obligation found for the requested reserve.")
+        obligation_options, selected_obligation = self._resolve_kamino_obligation_selection(
+            obligations=obligation_matches,
+            obligation_address=obligation_address,
+            action="withdraw",
+        )
+        selected_obligation_address = _kamino_entry_address(
+            selected_obligation,
+            "obligationAddress",
+            "obligation",
+            "address",
+            "pubkey",
+            "loanId",
+        )
         return {
             "chain": "solana",
             "network": self.network,
@@ -4072,7 +4211,14 @@ class SolanaWalletBackend(AgentWalletBackend):
             "reserve": reserve,
             "amount_ui": amount_ui,
             "reserve_info": reserve_entry,
-            "obligations": obligation_matches,
+            "obligations": obligation_options,
+            "obligation_options": [
+                _kamino_entry_address(item, "obligationAddress", "obligation", "address", "pubkey", "loanId")
+                for item in obligation_options
+                if _kamino_entry_address(item, "obligationAddress", "obligation", "address", "pubkey", "loanId")
+            ],
+            "obligation_address": selected_obligation_address or None,
+            "requires_obligation_address": selected_obligation is None and len(obligation_options) > 1,
             "sign_only": self.sign_only,
             "can_send": self.get_capabilities().can_send_transaction,
             "source": "kamino",
@@ -4083,12 +4229,23 @@ class SolanaWalletBackend(AgentWalletBackend):
         market: str,
         reserve: str,
         amount_ui: str,
+        obligation_address: str | None = None,
+        approved_preview: dict[str, Any] | None = None,
     ) -> dict[str, Any]:
-        preview = await self.preview_kamino_lend_withdraw(
+        preview = self._kamino_preview_from_approved(
+            approved_preview,
+            asset_type="kamino-lend-withdraw",
+        ) or await self.preview_kamino_lend_withdraw(
             market=market,
             reserve=reserve,
             amount_ui=amount_ui,
+            obligation_address=obligation_address,
         )
+        selected_obligation_address = str(preview.get("obligation_address") or "").strip()
+        if bool(preview.get("requires_obligation_address")) and not selected_obligation_address:
+            raise WalletBackendError(
+                "Kamino withdraw requires obligation_address when multiple obligations match the selected market/reserve."
+            )
         owner = str(preview["owner"])
         build = await kamino.build_lend_withdraw_transaction(
             wallet=owner,
@@ -4102,6 +4259,7 @@ class SolanaWalletBackend(AgentWalletBackend):
             market=str(preview["market"]),
             reserve=str(preview["reserve"]),
             amount_ui=str(preview["amount_ui"]),
+            obligation_address=selected_obligation_address or None,
         )
         prepared["build_response"] = build
         return prepared
@@ -4111,11 +4269,15 @@ class SolanaWalletBackend(AgentWalletBackend):
         market: str,
         reserve: str,
         amount_ui: str,
+        obligation_address: str | None = None,
+        approved_preview: dict[str, Any] | None = None,
     ) -> dict[str, Any]:
         prepared = await self.prepare_kamino_lend_withdraw(
             market=market,
             reserve=reserve,
             amount_ui=amount_ui,
+            obligation_address=obligation_address,
+            approved_preview=approved_preview,
         )
         result = await self._execute_prepared_provider_transaction(prepared, source="kamino")
         result["build_response"] = prepared.get("build_response")
@@ -4126,6 +4288,7 @@ class SolanaWalletBackend(AgentWalletBackend):
         market: str,
         reserve: str,
         amount_ui: str,
+        obligation_address: str | None = None,
     ) -> dict[str, Any]:
         self._require_mainnet_kamino("Kamino lending")
         owner = await self.get_address()
@@ -4146,6 +4309,19 @@ class SolanaWalletBackend(AgentWalletBackend):
         obligations = await self.get_kamino_lend_user_obligations(market=market, user=owner)
         if int(obligations["obligation_count"]) <= 0:
             raise WalletBackendError("Kamino borrow requires an existing obligation in the selected market.")
+        obligation_options, selected_obligation = self._resolve_kamino_obligation_selection(
+            obligations=list(obligations["obligations"]),
+            obligation_address=obligation_address,
+            action="borrow",
+        )
+        selected_obligation_address = _kamino_entry_address(
+            selected_obligation,
+            "obligationAddress",
+            "obligation",
+            "address",
+            "pubkey",
+            "loanId",
+        )
         return {
             "chain": "solana",
             "network": self.network,
@@ -4156,7 +4332,14 @@ class SolanaWalletBackend(AgentWalletBackend):
             "reserve": reserve,
             "amount_ui": amount_ui,
             "reserve_info": reserve_entry,
-            "obligations": obligations["obligations"],
+            "obligations": obligation_options,
+            "obligation_options": [
+                _kamino_entry_address(item, "obligationAddress", "obligation", "address", "pubkey", "loanId")
+                for item in obligation_options
+                if _kamino_entry_address(item, "obligationAddress", "obligation", "address", "pubkey", "loanId")
+            ],
+            "obligation_address": selected_obligation_address or None,
+            "requires_obligation_address": selected_obligation is None and len(obligation_options) > 1,
             "sign_only": self.sign_only,
             "can_send": self.get_capabilities().can_send_transaction,
             "source": "kamino",
@@ -4167,12 +4350,23 @@ class SolanaWalletBackend(AgentWalletBackend):
         market: str,
         reserve: str,
         amount_ui: str,
+        obligation_address: str | None = None,
+        approved_preview: dict[str, Any] | None = None,
     ) -> dict[str, Any]:
-        preview = await self.preview_kamino_lend_borrow(
+        preview = self._kamino_preview_from_approved(
+            approved_preview,
+            asset_type="kamino-lend-borrow",
+        ) or await self.preview_kamino_lend_borrow(
             market=market,
             reserve=reserve,
             amount_ui=amount_ui,
+            obligation_address=obligation_address,
         )
+        selected_obligation_address = str(preview.get("obligation_address") or "").strip()
+        if bool(preview.get("requires_obligation_address")) and not selected_obligation_address:
+            raise WalletBackendError(
+                "Kamino borrow requires obligation_address when multiple obligations exist in the selected market."
+            )
         owner = str(preview["owner"])
         build = await kamino.build_lend_borrow_transaction(
             wallet=owner,
@@ -4186,6 +4380,7 @@ class SolanaWalletBackend(AgentWalletBackend):
             market=str(preview["market"]),
             reserve=str(preview["reserve"]),
             amount_ui=str(preview["amount_ui"]),
+            obligation_address=selected_obligation_address or None,
         )
         prepared["build_response"] = build
         return prepared
@@ -4195,11 +4390,15 @@ class SolanaWalletBackend(AgentWalletBackend):
         market: str,
         reserve: str,
         amount_ui: str,
+        obligation_address: str | None = None,
+        approved_preview: dict[str, Any] | None = None,
     ) -> dict[str, Any]:
         prepared = await self.prepare_kamino_lend_borrow(
             market=market,
             reserve=reserve,
             amount_ui=amount_ui,
+            obligation_address=obligation_address,
+            approved_preview=approved_preview,
         )
         result = await self._execute_prepared_provider_transaction(prepared, source="kamino")
         result["build_response"] = prepared.get("build_response")
@@ -4210,6 +4409,7 @@ class SolanaWalletBackend(AgentWalletBackend):
         market: str,
         reserve: str,
         amount_ui: str,
+        obligation_address: str | None = None,
     ) -> dict[str, Any]:
         self._require_mainnet_kamino("Kamino lending")
         owner = await self.get_address()
@@ -4234,6 +4434,19 @@ class SolanaWalletBackend(AgentWalletBackend):
         )
         if not obligation_matches:
             raise WalletBackendError("No Kamino debt position found for the requested reserve.")
+        obligation_options, selected_obligation = self._resolve_kamino_obligation_selection(
+            obligations=obligation_matches,
+            obligation_address=obligation_address,
+            action="repay",
+        )
+        selected_obligation_address = _kamino_entry_address(
+            selected_obligation,
+            "obligationAddress",
+            "obligation",
+            "address",
+            "pubkey",
+            "loanId",
+        )
         return {
             "chain": "solana",
             "network": self.network,
@@ -4244,7 +4457,14 @@ class SolanaWalletBackend(AgentWalletBackend):
             "reserve": reserve,
             "amount_ui": amount_ui,
             "reserve_info": reserve_entry,
-            "obligations": obligation_matches,
+            "obligations": obligation_options,
+            "obligation_options": [
+                _kamino_entry_address(item, "obligationAddress", "obligation", "address", "pubkey", "loanId")
+                for item in obligation_options
+                if _kamino_entry_address(item, "obligationAddress", "obligation", "address", "pubkey", "loanId")
+            ],
+            "obligation_address": selected_obligation_address or None,
+            "requires_obligation_address": selected_obligation is None and len(obligation_options) > 1,
             "sign_only": self.sign_only,
             "can_send": self.get_capabilities().can_send_transaction,
             "source": "kamino",
@@ -4255,12 +4475,23 @@ class SolanaWalletBackend(AgentWalletBackend):
         market: str,
         reserve: str,
         amount_ui: str,
+        obligation_address: str | None = None,
+        approved_preview: dict[str, Any] | None = None,
     ) -> dict[str, Any]:
-        preview = await self.preview_kamino_lend_repay(
+        preview = self._kamino_preview_from_approved(
+            approved_preview,
+            asset_type="kamino-lend-repay",
+        ) or await self.preview_kamino_lend_repay(
             market=market,
             reserve=reserve,
             amount_ui=amount_ui,
+            obligation_address=obligation_address,
         )
+        selected_obligation_address = str(preview.get("obligation_address") or "").strip()
+        if bool(preview.get("requires_obligation_address")) and not selected_obligation_address:
+            raise WalletBackendError(
+                "Kamino repay requires obligation_address when multiple debt obligations match the selected market/reserve."
+            )
         owner = str(preview["owner"])
         build = await kamino.build_lend_repay_transaction(
             wallet=owner,
@@ -4274,6 +4505,7 @@ class SolanaWalletBackend(AgentWalletBackend):
             market=str(preview["market"]),
             reserve=str(preview["reserve"]),
             amount_ui=str(preview["amount_ui"]),
+            obligation_address=selected_obligation_address or None,
         )
         prepared["build_response"] = build
         return prepared
@@ -4283,11 +4515,15 @@ class SolanaWalletBackend(AgentWalletBackend):
         market: str,
         reserve: str,
         amount_ui: str,
+        obligation_address: str | None = None,
+        approved_preview: dict[str, Any] | None = None,
     ) -> dict[str, Any]:
         prepared = await self.prepare_kamino_lend_repay(
             market=market,
             reserve=reserve,
             amount_ui=amount_ui,
+            obligation_address=obligation_address,
+            approved_preview=approved_preview,
         )
         result = await self._execute_prepared_provider_transaction(prepared, source="kamino")
         result["build_response"] = prepared.get("build_response")
@@ -5426,7 +5662,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 +5684,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 +5751,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 +5869,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 +5938,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 +6104,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: