@agentlayer.tech/wallet 0.1.44 → 0.1.48

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

@@ -117,6 +117,7 @@ async def fetch_quote(
     restrict_intermediate_tokens: bool = True,
     only_direct_routes: bool = False,
     swap_mode: str = "ExactIn",
+    exclude_dexes: list[str] | None = None,
 ) -> dict[str, Any]:
     """Fetch a Jupiter quote for an exact-in swap.
 
@@ -133,6 +134,7 @@ async def fetch_quote(
             restrict_intermediate_tokens=restrict_intermediate_tokens,
             only_direct_routes=only_direct_routes,
             swap_mode=swap_mode,
+            exclude_dexes=exclude_dexes,
         )
     except ProviderError as exc:
         error_msg = str(exc).lower()
@@ -168,6 +170,7 @@ async def _fetch_quote_direct(
     restrict_intermediate_tokens: bool = True,
     only_direct_routes: bool = False,
     swap_mode: str = "ExactIn",
+    exclude_dexes: list[str] | None = None,
 ) -> dict[str, Any]:
     """Fetch a Jupiter quote directly from Jupiter API."""
     client = get_client()
@@ -180,6 +183,8 @@ async def _fetch_quote_direct(
         "restrictIntermediateTokens": str(restrict_intermediate_tokens).lower(),
         "onlyDirectRoutes": str(only_direct_routes).lower(),
     }
+    if exclude_dexes:
+        params["excludeDexes"] = ",".join(str(d).strip() for d in exclude_dexes if str(d).strip())
     response = await client.get(
         f"{settings.jupiter_api_base_url.rstrip('/')}/quote",
         params=params,

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

@@ -18,6 +18,12 @@ LONG_RUNNING_POST_PATHS = {
     "/v1/evm/aave/withdraw/send",
     "/v1/evm/aave/borrow/send",
     "/v1/evm/aave/repay/send",
+    "/v1/evm/morpho/vault/supply/send",
+    "/v1/evm/morpho/vault/withdraw/send",
+    "/v1/evm/morpho/market/supply_collateral/send",
+    "/v1/evm/morpho/market/borrow/send",
+    "/v1/evm/morpho/market/repay/send",
+    "/v1/evm/morpho/market/withdraw_collateral/send",
     "/v1/evm/lido/stake_eth_for_wsteth/send",
     "/v1/evm/lido/wrap_steth/send",
     "/v1/evm/lido/unwrap_wsteth/send",

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

@@ -120,6 +120,35 @@ class AgentWalletBackend(ABC):
     async def get_evm_lido_withdrawal_requests(self) -> dict[str, Any]:
         raise WalletBackendError(f"{self.name} does not support EVM Lido withdrawal lookup.")
 
+    async def get_evm_morpho_vaults(
+        self,
+        *,
+        vault_address: str | None = None,
+        limit: int | None = None,
+        listed_only: bool = True,
+        asset_address: str | None = None,
+        order_by: str | None = None,
+        order_direction: str | None = None,
+    ) -> dict[str, Any]:
+        raise WalletBackendError(f"{self.name} does not support EVM Morpho vault lookup.")
+
+    async def get_evm_morpho_markets(
+        self,
+        *,
+        market_id: str | None = None,
+        limit: int | None = None,
+        listed_only: bool = True,
+        search: str | None = None,
+        collateral_asset_address: str | None = None,
+        loan_asset_address: str | None = None,
+        order_by: str | None = None,
+        order_direction: str | None = None,
+    ) -> dict[str, Any]:
+        raise WalletBackendError(f"{self.name} does not support EVM Morpho market lookup.")
+
+    async def get_evm_morpho_positions(self) -> dict[str, Any]:
+        raise WalletBackendError(f"{self.name} does not support EVM Morpho positions lookup.")
+
     async def preview_evm_aave_operation(
         self,
         *,
@@ -175,6 +204,56 @@ class AgentWalletBackend(ABC):
     ) -> dict[str, Any]:
         raise WalletBackendError(f"{self.name} does not support EVM Lido withdrawals.")
 
+    async def preview_evm_morpho_vault_operation(
+        self,
+        *,
+        operation: str,
+        token_address: str,
+        vault_address: str | None = None,
+        vault_preset: str | None = None,
+        amount_raw: str | None = None,
+        native_amount_raw: str | None = None,
+    ) -> dict[str, Any]:
+        raise WalletBackendError(f"{self.name} does not support EVM Morpho vault previews.")
+
+    async def send_evm_morpho_vault_operation(
+        self,
+        *,
+        operation: str,
+        token_address: str,
+        vault_address: str | None = None,
+        vault_preset: str | None = None,
+        amount_raw: str | None = None,
+        native_amount_raw: str | None = None,
+        expected_quote_fingerprint: str | None = None,
+    ) -> dict[str, Any]:
+        raise WalletBackendError(f"{self.name} does not support EVM Morpho vault operations.")
+
+    async def preview_evm_morpho_market_operation(
+        self,
+        *,
+        operation: str,
+        token_address: str,
+        market_id: str | None = None,
+        market_preset: str | None = None,
+        amount_raw: str | None = None,
+        native_amount_raw: str | None = None,
+    ) -> dict[str, Any]:
+        raise WalletBackendError(f"{self.name} does not support EVM Morpho market previews.")
+
+    async def send_evm_morpho_market_operation(
+        self,
+        *,
+        operation: str,
+        token_address: str,
+        market_id: str | None = None,
+        market_preset: str | None = None,
+        amount_raw: str | None = None,
+        native_amount_raw: str | None = None,
+        expected_quote_fingerprint: str | None = None,
+    ) -> dict[str, Any]:
+        raise WalletBackendError(f"{self.name} does not support EVM Morpho market operations.")
+
     async def preview_evm_swap(
         self,
         *,
@@ -524,6 +603,116 @@ class AgentWalletBackend(ABC):
     ) -> dict[str, Any]:
         raise WalletBackendError(f"{self.name} does not support Kamino withdraw previews.")
 
+    def _build_kamino_lend_intent_preview(
+        self,
+        base_preview: dict[str, Any],
+        *,
+        valid_for_seconds: int,
+    ) -> dict[str, Any]:
+        """Wrap a base Kamino lend preview into an intent approval preview.
+
+        The intent binds approval to stable semantic parameters (owner, market,
+        reserve, amount, obligation) instead of an ephemeral preview digest, so
+        execute can re-derive the transaction server-side without the host having
+        to round-trip the full preview payload back as _approved_preview.
+        """
+        if valid_for_seconds <= 0 or valid_for_seconds > 300:
+            raise WalletBackendError("valid_for_seconds must be between 1 and 300.")
+        try:
+            can_send = bool(self.get_capabilities().can_send_transaction)
+        except Exception:
+            can_send = bool(base_preview.get("can_send"))
+        return {
+            "chain": "solana",
+            "network": getattr(self, "network", "mainnet"),
+            "mode": "intent_preview",
+            "asset_type": "kamino-lend-intent",
+            "kamino_operation": base_preview["asset_type"],
+            "owner": base_preview["owner"],
+            "market": base_preview["market"],
+            "reserve": base_preview["reserve"],
+            "amount_ui": base_preview["amount_ui"],
+            "obligation_address": base_preview.get("obligation_address"),
+            "obligation_options": base_preview.get("obligation_options", []),
+            "requires_obligation_address": bool(base_preview.get("requires_obligation_address")),
+            "reserve_info": base_preview.get("reserve_info"),
+            "recipient_policy": "owner-only",
+            "spend_policy": "exact-amount",
+            "valid_for_seconds": valid_for_seconds,
+            "valid_until_epoch_seconds": int(time.time()) + valid_for_seconds,
+            "intent_note": (
+                "This is an intent approval preview. Execute re-derives the Kamino "
+                "transaction and only signs/sends if it remains within these approved parameters."
+            ),
+            "can_send": can_send,
+            "sign_only": bool(getattr(self, "sign_only", False)),
+            "source": "kamino-intent",
+        }
+
+    async def preview_kamino_lend_deposit_intent(
+        self,
+        market: str,
+        reserve: str,
+        amount_ui: str,
+        obligation_address: str | None = None,
+        valid_for_seconds: int = 120,
+    ) -> dict[str, Any]:
+        base = await self.preview_kamino_lend_deposit(
+            market=market,
+            reserve=reserve,
+            amount_ui=amount_ui,
+            obligation_address=obligation_address,
+        )
+        return self._build_kamino_lend_intent_preview(base, valid_for_seconds=valid_for_seconds)
+
+    async def preview_kamino_lend_withdraw_intent(
+        self,
+        market: str,
+        reserve: str,
+        amount_ui: str,
+        obligation_address: str | None = None,
+        valid_for_seconds: int = 120,
+    ) -> dict[str, Any]:
+        base = await self.preview_kamino_lend_withdraw(
+            market=market,
+            reserve=reserve,
+            amount_ui=amount_ui,
+            obligation_address=obligation_address,
+        )
+        return self._build_kamino_lend_intent_preview(base, valid_for_seconds=valid_for_seconds)
+
+    async def preview_kamino_lend_borrow_intent(
+        self,
+        market: str,
+        reserve: str,
+        amount_ui: str,
+        obligation_address: str | None = None,
+        valid_for_seconds: int = 120,
+    ) -> dict[str, Any]:
+        base = await self.preview_kamino_lend_borrow(
+            market=market,
+            reserve=reserve,
+            amount_ui=amount_ui,
+            obligation_address=obligation_address,
+        )
+        return self._build_kamino_lend_intent_preview(base, valid_for_seconds=valid_for_seconds)
+
+    async def preview_kamino_lend_repay_intent(
+        self,
+        market: str,
+        reserve: str,
+        amount_ui: str,
+        obligation_address: str | None = None,
+        valid_for_seconds: int = 120,
+    ) -> dict[str, Any]:
+        base = await self.preview_kamino_lend_repay(
+            market=market,
+            reserve=reserve,
+            amount_ui=amount_ui,
+            obligation_address=obligation_address,
+        )
+        return self._build_kamino_lend_intent_preview(base, valid_for_seconds=valid_for_seconds)
+
     async def prepare_kamino_lend_withdraw(
         self,
         market: str,

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

@@ -4704,6 +4704,7 @@ class SolanaWalletBackend(AgentWalletBackend):
         amount_ui: float,
         slippage_bps: int = SOLANA_SWAP_DEFAULT_SLIPPAGE_BPS,
         exclude_routers: list[str] | None = None,
+        exclude_dexes: list[str] | None = None,
     ) -> dict[str, Any]:
         if self.network != "mainnet":
             raise WalletBackendError("Provider-routed swaps are only enabled for Solana mainnet.")
@@ -4749,6 +4750,7 @@ class SolanaWalletBackend(AgentWalletBackend):
                     output_mint=output_mint,
                     amount_raw=raw_amount,
                     slippage_bps=slippage_bps,
+                    exclude_dexes=exclude_dexes,
                 )
                 quote_source = "jupiter-metis"
 
@@ -5006,17 +5008,27 @@ class SolanaWalletBackend(AgentWalletBackend):
 
         attempts: list[dict[str, Any]] = []
         last_error: str | None = None
+        _simulation_failed = False
         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
+                # On retries after a simulation failure, exclude DEXes known to fail
+                # simulation for Token-2022 tokens with extensions such as
+                # scaledUiAmountConfig, pausableConfig, or permanentDelegate
+                # (e.g. Backpack xStock tokens). GoonFi V2 is the primary offender;
+                # ZeroFi handles these tokens correctly.
+                exclude_dexes: list[str] | None = None
+                if _simulation_failed and attempt_index > 0:
+                    exclude_dexes = ["GoonFi V2"]
                 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,
+                    exclude_dexes=exclude_dexes,
                 )
                 estimated_output_raw = int(preview.get("estimated_output_amount_raw") or 0)
                 if (
@@ -5073,6 +5085,8 @@ class SolanaWalletBackend(AgentWalletBackend):
                 return result
             except (WalletBackendError, ProviderError) as exc:
                 last_error = str(exc)
+                if "simulation failed" in str(exc).lower():
+                    _simulation_failed = True
                 attempts.append(
                     {
                         "attempt": attempt_index + 1,