@agentlayer.tech/wallet 0.1.25 → 0.1.27

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
 
@@ -524,6 +525,7 @@ class AgentWalletBackend(ABC):
         market: str,
         reserve: str,
         amount_ui: str,
+        obligation_address: str | None = None,
     ) -> dict[str, Any]:
         raise WalletBackendError(f"{self.name} does not support Kamino deposit previews.")
 
@@ -532,6 +534,8 @@ class AgentWalletBackend(ABC):
         market: str,
         reserve: str,
         amount_ui: str,
+        obligation_address: str | None = None,
+        approved_preview: dict[str, Any] | None = None,
     ) -> dict[str, Any]:
         raise WalletBackendError(f"{self.name} does not support Kamino deposit preparation.")
 
@@ -540,6 +544,8 @@ class AgentWalletBackend(ABC):
         market: str,
         reserve: str,
         amount_ui: str,
+        obligation_address: str | None = None,
+        approved_preview: dict[str, Any] | None = None,
     ) -> dict[str, Any]:
         raise WalletBackendError(f"{self.name} does not support Kamino deposits.")
 
@@ -548,6 +554,7 @@ class AgentWalletBackend(ABC):
         market: str,
         reserve: str,
         amount_ui: str,
+        obligation_address: str | None = None,
     ) -> dict[str, Any]:
         raise WalletBackendError(f"{self.name} does not support Kamino withdraw previews.")
 
@@ -556,6 +563,8 @@ class AgentWalletBackend(ABC):
         market: str,
         reserve: str,
         amount_ui: str,
+        obligation_address: str | None = None,
+        approved_preview: dict[str, Any] | None = None,
     ) -> dict[str, Any]:
         raise WalletBackendError(f"{self.name} does not support Kamino withdraw preparation.")
 
@@ -564,6 +573,8 @@ class AgentWalletBackend(ABC):
         market: str,
         reserve: str,
         amount_ui: str,
+        obligation_address: str | None = None,
+        approved_preview: dict[str, Any] | None = None,
     ) -> dict[str, Any]:
         raise WalletBackendError(f"{self.name} does not support Kamino withdraws.")
 
@@ -572,6 +583,7 @@ class AgentWalletBackend(ABC):
         market: str,
         reserve: str,
         amount_ui: str,
+        obligation_address: str | None = None,
     ) -> dict[str, Any]:
         raise WalletBackendError(f"{self.name} does not support Kamino borrow previews.")
 
@@ -580,6 +592,8 @@ class AgentWalletBackend(ABC):
         market: str,
         reserve: str,
         amount_ui: str,
+        obligation_address: str | None = None,
+        approved_preview: dict[str, Any] | None = None,
     ) -> dict[str, Any]:
         raise WalletBackendError(f"{self.name} does not support Kamino borrow preparation.")
 
@@ -588,6 +602,8 @@ class AgentWalletBackend(ABC):
         market: str,
         reserve: str,
         amount_ui: str,
+        obligation_address: str | None = None,
+        approved_preview: dict[str, Any] | None = None,
     ) -> dict[str, Any]:
         raise WalletBackendError(f"{self.name} does not support Kamino borrows.")
 
@@ -596,6 +612,7 @@ class AgentWalletBackend(ABC):
         market: str,
         reserve: str,
         amount_ui: str,
+        obligation_address: str | None = None,
     ) -> dict[str, Any]:
         raise WalletBackendError(f"{self.name} does not support Kamino repay previews.")
 
@@ -604,6 +621,8 @@ class AgentWalletBackend(ABC):
         market: str,
         reserve: str,
         amount_ui: str,
+        obligation_address: str | None = None,
+        approved_preview: dict[str, Any] | None = None,
     ) -> dict[str, Any]:
         raise WalletBackendError(f"{self.name} does not support Kamino repay preparation.")
 
@@ -612,6 +631,8 @@ class AgentWalletBackend(ABC):
         market: str,
         reserve: str,
         amount_ui: str,
+        obligation_address: str | None = None,
+        approved_preview: dict[str, Any] | None = None,
     ) -> dict[str, Any]:
         raise WalletBackendError(f"{self.name} does not support Kamino repays.")
 
@@ -731,16 +752,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 +831,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 +839,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 +851,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,