@agentlayer.tech/wallet 0.1.26 → 0.1.27

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

@@ -1535,6 +1535,7 @@ const solanaToolDefinitions = [
         market: { type: "string" },
         reserve: { type: "string" },
         amount_ui: { type: "string" },
+        obligation_address: { type: "string" },
         mode: { type: "string", enum: ["preview", "prepare", "execute"] },
         purpose: { type: "string" },
         user_intent: { type: "boolean" },
@@ -1553,6 +1554,7 @@ const solanaToolDefinitions = [
         market: { type: "string" },
         reserve: { type: "string" },
         amount_ui: { type: "string" },
+        obligation_address: { type: "string" },
         mode: { type: "string", enum: ["preview", "prepare", "execute"] },
         purpose: { type: "string" },
         user_intent: { type: "boolean" },
@@ -1571,6 +1573,7 @@ const solanaToolDefinitions = [
         market: { type: "string" },
         reserve: { type: "string" },
         amount_ui: { type: "string" },
+        obligation_address: { type: "string" },
         mode: { type: "string", enum: ["preview", "prepare", "execute"] },
         purpose: { type: "string" },
         user_intent: { type: "boolean" },

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

@@ -1535,6 +1535,7 @@ const solanaToolDefinitions = [
         market: { type: "string" },
         reserve: { type: "string" },
         amount_ui: { type: "string" },
+        obligation_address: { type: "string" },
         mode: { type: "string", enum: ["preview", "prepare", "execute"] },
         purpose: { type: "string" },
         user_intent: { type: "boolean" },
@@ -1553,6 +1554,7 @@ const solanaToolDefinitions = [
         market: { type: "string" },
         reserve: { type: "string" },
         amount_ui: { type: "string" },
+        obligation_address: { type: "string" },
         mode: { type: "string", enum: ["preview", "prepare", "execute"] },
         purpose: { type: "string" },
         user_intent: { type: "boolean" },
@@ -1571,6 +1573,7 @@ const solanaToolDefinitions = [
         market: { type: "string" },
         reserve: { type: "string" },
         amount_ui: { type: "string" },
+        obligation_address: { type: "string" },
         mode: { type: "string", enum: ["preview", "prepare", "execute"] },
         purpose: { type: "string" },
         user_intent: { type: "boolean" },

package/.openclaw/extensions/agent-wallet/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agentlayertech/agent-wallet-plugin",
-  "version": "0.1.24",
+  "version": "0.1.27",
   "description": "OpenClaw plugin bridge for the AgentLayer wallet runtime.",
   "type": "module",
   "license": "SEE LICENSE IN ../../../LICENSE",

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

@@ -13,6 +13,7 @@ Safety rules:
 - For transfers, native staking, swaps, Aave writes, Jupiter Earn writes, and Kamino writes, use `preview` before `prepare` or `execute`.
 - For Solana Jupiter swaps through `swap_solana_tokens`, prefer `intent_preview` then `intent_execute` after explicit chat confirmation. The user confirms risk limits; the backend refreshes the quote and only executes inside those limits.
 - Solana swap intent defaults to at least 300 bps (3%) slippage, 120 seconds validity, and 3 fresh execution attempts. The backend computes the approved minimum output from the indicative output and slippage, clamps hand-tightened minimums to that floor, then executes through Jupiter Swap API V2 `/order` + `/execute` when available.
+- Metis `/swap` fallback builds use Jupiter dynamic slippage and a bounded `veryHigh` priority fee instead of the old `"auto"` priority mode.
 - Do not use legacy `execute` for Solana Jupiter swaps in OpenClaw. Exact quote-bound approval is too fragile for active markets and will be rejected by the bridge.
 - For `swap_solana_privately`, use `preview` and then `execute` after explicit user approval. Do not use `prepare` for this tool.
 - Use `prepare` only when the user clearly intends to produce an execution plan.

package/CHANGELOG.md

@@ -2,6 +2,18 @@
 
 ## Unreleased
 
+## v0.1.27 - 2026-05-27
+
+- Improved Solana swap fallback landing by enabling Jupiter dynamic slippage
+  and bounded `veryHigh` priority fees on the Metis `/swap` fallback path.
+- Hardened Kamino transaction execution with local simulation before send,
+  Kamino-specific build timeouts, and longer confirmation polling on mainnet.
+- Reused approved Kamino preview payloads during execute so OpenClaw no longer
+  needs to rebuild the same write path just to satisfy approval binding.
+- Added Kamino obligation pinning for `withdraw`, `borrow`, and `repay`, so
+  preview can require an explicit `obligation_address` and execute verifies the
+  built transaction references the selected obligation before signing.
+
 ## v0.1.26 - 2026-05-26
 
 - Reworked Solana Jupiter swaps to prefer intent approvals, so OpenClaw confirms

package/agent-wallet/agent_wallet/openclaw_adapter.py

@@ -760,6 +760,7 @@ class OpenClawWalletAdapter:
             "owner",
             "authority",
             "address",
+            "obligation_address",
             "market",
             "reserve",
             "amount_native",
@@ -2969,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"],
@@ -3003,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"],
@@ -3037,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"],
@@ -5003,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)
@@ -5014,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():
@@ -5046,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,
@@ -5063,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,
@@ -5077,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,

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,32 @@ 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",
@@ -456,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,
@@ -483,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)

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

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

@@ -525,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.")
 
@@ -533,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.")
 
@@ -541,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.")
 
@@ -549,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.")
 
@@ -557,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.")
 
@@ -565,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.")
 
@@ -573,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.")
 
@@ -581,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.")
 
@@ -589,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.")
 
@@ -597,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.")
 
@@ -605,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.")
 
@@ -613,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.")
 

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

@@ -3765,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):
@@ -3789,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,
@@ -3847,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
@@ -3858,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 {
@@ -3875,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]:
@@ -3925,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,
         *,
@@ -3933,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.")
@@ -3953,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,
@@ -3967,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",
@@ -3975,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()
@@ -4021,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,
@@ -4049,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")
@@ -4064,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()
@@ -4088,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,
@@ -4098,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",
@@ -4109,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,
@@ -4128,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
@@ -4137,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")
@@ -4152,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()
@@ -4172,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,
@@ -4182,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",
@@ -4193,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,
@@ -4212,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
@@ -4221,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")
@@ -4236,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()
@@ -4260,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,
@@ -4270,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",
@@ -4281,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,
@@ -4300,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
@@ -4309,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")

package/agent-wallet/pyproject.toml

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

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

@@ -80,6 +80,7 @@ Use this skill before calling OpenClaw wallet tools. It is the routing guide for
   - Prefer `mode=intent_preview`, show the intent limits to the user, then after chat confirmation call `mode=intent_execute` with the same semantic params. This confirms risk limits, not a stale quote fingerprint.
   - Default Solana swap slippage is 300 bps (3%). The backend computes the approved minimum output from the indicative output and slippage, not from a strict RFQ threshold.
   - The primary execution path uses Jupiter Swap API V2 `/order` + `/execute`; if a JupiterZ/RFQ route fails, the backend retries with a non-JupiterZ route when possible.
+  - Metis `/swap` fallback builds use Jupiter dynamic slippage and a bounded `veryHigh` priority fee instead of the old `"auto"` priority mode.
   - Do not use legacy `execute` for Solana Jupiter swaps in OpenClaw; exact quote-bound approval is too fragile for active markets.
   - Use for SOL<->SPL or SPL<->SPL on Solana. Do not use LI.FI for Solana-only swaps.
 - EVM same-chain Velora swap: `swap_evm_tokens`

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agentlayer.tech/wallet",
-  "version": "0.1.26",
+  "version": "0.1.27",
   "description": "NPM installer for the OpenClaw Agent Wallet local runtime.",
   "type": "module",
   "repository": {