@agentlayer.tech/wallet 0.1.25 → 0.1.27

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,
@@ -738,6 +760,7 @@ class OpenClawWalletAdapter:
             "owner",
             "authority",
             "address",
+            "obligation_address",
             "market",
             "reserve",
             "amount_native",
@@ -2451,7 +2474,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 +2495,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",
@@ -2929,6 +2970,10 @@ class OpenClawWalletAdapter:
                                 "type": "string",
                                 "description": "Decimal token amount to withdraw, as a string.",
                             },
+                            "obligation_address": {
+                                "type": "string",
+                                "description": "Optional Kamino obligation address. Required when preview shows multiple matching obligations.",
+                            },
                             "mode": {
                                 "type": "string",
                                 "enum": ["preview", "prepare", "execute"],
@@ -2963,6 +3008,10 @@ class OpenClawWalletAdapter:
                                 "type": "string",
                                 "description": "Decimal token amount to borrow, as a string.",
                             },
+                            "obligation_address": {
+                                "type": "string",
+                                "description": "Optional Kamino obligation address. Required when preview shows multiple obligations in the selected market.",
+                            },
                             "mode": {
                                 "type": "string",
                                 "enum": ["preview", "prepare", "execute"],
@@ -2997,6 +3046,10 @@ class OpenClawWalletAdapter:
                                 "type": "string",
                                 "description": "Decimal token amount to repay, as a string.",
                             },
+                            "obligation_address": {
+                                "type": "string",
+                                "description": "Optional Kamino obligation address. Required when preview shows multiple matching debt obligations.",
+                            },
                             "mode": {
                                 "type": "string",
                                 "enum": ["preview", "prepare", "execute"],
@@ -4963,6 +5016,7 @@ class OpenClawWalletAdapter:
                 market = args.get("market")
                 reserve = args.get("reserve")
                 amount_ui = args.get("amount_ui")
+                obligation_address = args.get("obligation_address")
                 mode = args.get("mode")
                 purpose = args.get("purpose")
                 user_intent = args.get("user_intent", False)
@@ -4974,6 +5028,8 @@ class OpenClawWalletAdapter:
                     raise WalletBackendError("reserve is required.")
                 if not isinstance(amount_ui, str) or not amount_ui.strip():
                     raise WalletBackendError("amount_ui is required.")
+                if obligation_address is not None and not isinstance(obligation_address, str):
+                    raise WalletBackendError("obligation_address must be a string when provided.")
                 if mode not in {"preview", "prepare", "execute"}:
                     raise WalletBackendError("mode must be 'preview', 'prepare' or 'execute'.")
                 if not isinstance(purpose, str) or not purpose.strip():
@@ -5006,6 +5062,7 @@ class OpenClawWalletAdapter:
                         market=market.strip(),
                         reserve=reserve.strip(),
                         amount_ui=amount_ui.strip(),
+                        obligation_address=obligation_address.strip() if isinstance(obligation_address, str) and obligation_address.strip() else None,
                     )
                     return AgentToolResult(
                         tool=tool_name,
@@ -5023,7 +5080,12 @@ class OpenClawWalletAdapter:
                         market=market.strip(),
                         reserve=reserve.strip(),
                         amount_ui=amount_ui.strip(),
+                        obligation_address=obligation_address.strip() if isinstance(obligation_address, str) and obligation_address.strip() else None,
                     )
+                    if bool(preview.get("requires_obligation_address")):
+                        raise WalletBackendError(
+                            f"{action_label} requires obligation_address when multiple Kamino obligations match the selected position."
+                        )
                     return AgentToolResult(
                         tool=tool_name,
                         ok=True,
@@ -5037,24 +5099,49 @@ class OpenClawWalletAdapter:
                         ),
                     )
 
-                execute_preview = await preview_method(
-                    market=market.strip(),
-                    reserve=reserve.strip(),
-                    amount_ui=amount_ui.strip(),
+                approved_preview = args.get("_approved_preview")
+                execute_preview = None
+                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 approval after previewing the exact action."
+                    )
+                approval_summary_copy = dict(approval_summary)
+                if isinstance(approval_summary_copy.get("_preview_digest"), str):
+                    if not isinstance(approved_preview, dict):
+                        raise WalletBackendError(
+                            f"Approved {action_label} preview payload is required for execute mode. Generate a new preview and approval before execute."
+                        )
+                    if preview_payload_digest(approved_preview) != approval_summary_copy["_preview_digest"]:
+                        raise WalletBackendError(
+                            "approved preview payload does not match the approval token. Generate a new preview and approval before execute."
+                        )
+                    execute_preview = dict(approved_preview)
+                else:
+                    execute_preview = await preview_method(
+                        market=market.strip(),
+                        reserve=reserve.strip(),
+                        amount_ui=amount_ui.strip(),
+                        obligation_address=obligation_address.strip() if isinstance(obligation_address, str) and obligation_address.strip() else None,
+                    )
                 self._require_execute_approval(
                     approval_token=approval_token,
                     tool_name=tool_name,
-                    summary=self._build_confirmation_summary(
-                        action_label=action_label,
-                        payload=execute_preview,
-                    ),
+                    summary=approval_summary_copy,
                     action_label=action_label,
                 )
                 result = await execute_method(
                     market=market.strip(),
                     reserve=reserve.strip(),
                     amount_ui=amount_ui.strip(),
+                    obligation_address=obligation_address.strip() if isinstance(obligation_address, str) and obligation_address.strip() else None,
+                    approved_preview=execute_preview,
                 )
                 return AgentToolResult(
                     tool=tool_name,
@@ -5248,7 +5335,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 +5353,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 +5393,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 +5435,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

@@ -10,6 +10,8 @@ from agent_wallet.config import settings
 from agent_wallet.exceptions import ProviderError
 from agent_wallet.http_client import get_client
 
+JUPITER_SWAP_FALLBACK_PRIORITY_MAX_LAMPORTS = 2_000_000
+
 
 def _headers() -> dict[str, str]:
     headers = {"Accept": "application/json"}
@@ -91,6 +93,39 @@ def _direct_jupiter_enabled() -> bool:
     return bool(settings.jupiter_api_key.strip())
 
 
+def _swap_fallback_prioritization_fee() -> dict[str, Any]:
+    return {
+        "priorityLevelWithMaxLamports": {
+            "priorityLevel": "veryHigh",
+            "maxLamports": JUPITER_SWAP_FALLBACK_PRIORITY_MAX_LAMPORTS,
+            "global": False,
+        }
+    }
+
+
+def _swap_fallback_build_body(
+    *,
+    user_public_key: str,
+    quote_response: dict[str, Any],
+    wrap_and_unwrap_sol: bool,
+) -> dict[str, Any]:
+    return {
+        "userPublicKey": user_public_key,
+        "quoteResponse": quote_response,
+        "wrapAndUnwrapSol": wrap_and_unwrap_sol,
+        "dynamicComputeUnitLimit": True,
+        "dynamicSlippage": True,
+        "prioritizationFeeLamports": _swap_fallback_prioritization_fee(),
+    }
+
+
+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 +402,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,
@@ -403,13 +484,11 @@ async def _build_swap_direct(
 ) -> dict[str, Any]:
     """Build a swap transaction directly via Jupiter API."""
     client = get_client()
-    body = {
-        "userPublicKey": user_public_key,
-        "quoteResponse": quote_response,
-        "wrapAndUnwrapSol": wrap_and_unwrap_sol,
-        "dynamicComputeUnitLimit": True,
-        "prioritizationFeeLamports": "auto",
-    }
+    body = _swap_fallback_build_body(
+        user_public_key=user_public_key,
+        quote_response=quote_response,
+        wrap_and_unwrap_sol=wrap_and_unwrap_sol,
+    )
     response = await client.post(
         f"{settings.jupiter_api_base_url.rstrip('/')}/swap",
         json=body,
@@ -430,13 +509,11 @@ async def _build_swap_via_gateway(
     wrap_and_unwrap_sol: bool = True,
 ) -> dict[str, Any]:
     """Build a swap transaction via provider gateway (uses API key)."""
-    body = {
-        "userPublicKey": user_public_key,
-        "quoteResponse": quote_response,
-        "wrapAndUnwrapSol": wrap_and_unwrap_sol,
-        "dynamicComputeUnitLimit": True,
-        "prioritizationFeeLamports": "auto",
-    }
+    body = _swap_fallback_build_body(
+        user_public_key=user_public_key,
+        quote_response=quote_response,
+        wrap_and_unwrap_sol=wrap_and_unwrap_sol,
+    )
     status_code, payload = await _gateway_post("swap", body=body)
     if status_code != 200:
         error_msg = payload if isinstance(payload, str) else json.dumps(payload)
@@ -477,6 +554,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/providers/kamino.py

@@ -8,6 +8,8 @@ from agent_wallet.config import settings
 from agent_wallet.exceptions import ProviderError
 from agent_wallet.http_client import get_client
 
+KAMINO_BUILD_TIMEOUT_SECONDS = 20.0
+
 
 def _normalized_api_base() -> str:
     return settings.kamino_api_base_url.rstrip("/")
@@ -140,6 +142,7 @@ async def build_lend_deposit_transaction(
             "reserve": reserve,
             "amount": amount_ui,
         },
+        timeout=KAMINO_BUILD_TIMEOUT_SECONDS,
     )
     if response.status_code != 200:
         raise ProviderError("kamino", f"HTTP {response.status_code}: {response.text[:300]}")
@@ -163,6 +166,7 @@ async def build_lend_withdraw_transaction(
             "reserve": reserve,
             "amount": amount_ui,
         },
+        timeout=KAMINO_BUILD_TIMEOUT_SECONDS,
     )
     if response.status_code != 200:
         raise ProviderError("kamino", f"HTTP {response.status_code}: {response.text[:300]}")
@@ -186,6 +190,7 @@ async def build_lend_borrow_transaction(
             "reserve": reserve,
             "amount": amount_ui,
         },
+        timeout=KAMINO_BUILD_TIMEOUT_SECONDS,
     )
     if response.status_code != 200:
         raise ProviderError("kamino", f"HTTP {response.status_code}: {response.text[:300]}")
@@ -209,6 +214,7 @@ async def build_lend_repay_transaction(
             "reserve": reserve,
             "amount": amount_ui,
         },
+        timeout=KAMINO_BUILD_TIMEOUT_SECONDS,
     )
     if response.status_code != 200:
         raise ProviderError("kamino", f"HTTP {response.status_code}: {response.text[:300]}")

package/agent-wallet/agent_wallet/transaction_policy.py

@@ -718,6 +718,7 @@ def verify_provider_kamino_lend_transaction(
     market_address: str,
     reserve_address: str,
     action: str,
+    obligation_address: str | None = None,
     loaded_addresses: list[str] | None = None,
 ) -> dict[str, Any]:
     binding = _assert_basic_wallet_binding(
@@ -734,6 +735,10 @@ def verify_provider_kamino_lend_transaction(
         raise WalletBackendError(
             f"{action} transaction does not reference the expected Kamino reserve."
         )
+    if obligation_address and obligation_address not in keys:
+        raise WalletBackendError(
+            f"{action} transaction does not reference the expected Kamino obligation."
+        )
     program_ids = _program_ids(message, loaded_addresses)
     unknown_program_ids = _assert_program_allowlist(
         program_ids,
@@ -764,6 +769,7 @@ def verify_provider_kamino_lend_transaction(
         "instruction_count": len(_compiled_instructions(message)),
         "market_address": market_address,
         "reserve_address": reserve_address,
+        "obligation_address": obligation_address,
         "action": action,
         "verified": True,
     }