@agentlayer.tech/wallet 0.1.28 → 0.1.32

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

@@ -11,8 +11,9 @@ import time
 from decimal import Decimal, InvalidOperation
 from typing import Any
 
+from agent_wallet.config import normalize_solana_network
 from agent_wallet.models import AgentWalletCapabilities, SolanaWalletState
-from agent_wallet.providers import bags, flash, flash_sdk_bridge, houdini, jupiter, kamino, lifi, solana_rpc
+from agent_wallet.providers import bags, flash, flash_sdk_bridge, jupiter, kamino, lifi, solana_rpc
 from agent_wallet.solana_stake import (
     STAKE_STATE_V2_SIZE,
     deactivate_stake as build_deactivate_stake_instruction,
@@ -29,7 +30,6 @@ from agent_wallet.transaction_policy import (
     verify_provider_bags_transaction,
     verify_provider_flash_transaction,
     verify_provider_kamino_lend_transaction,
-    verify_provider_lend_transaction,
     verify_provider_swap_simulation_result,
     verify_provider_swap_transaction,
 )
@@ -48,9 +48,9 @@ TOKEN_PROGRAM_ID = "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA"
 TOKEN_2022_PROGRAM_ID = "TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb"
 NATIVE_SOL_MINT = "So11111111111111111111111111111111111111112"
 STAKE_PROGRAM_ID = "Stake11111111111111111111111111111111111111"
-HOUDINI_PRIVATE_OUTPUT_DRIFT_BPS = 600
 SOLANA_SWAP_DEFAULT_SLIPPAGE_BPS = 300
 SOLANA_SWAP_INTENT_DEFAULT_MAX_FEE_LAMPORTS = 6_000_000
+KAMINO_OPEN_POSITIONS_SCAN_CONCURRENCY = 6
 
 
 def _load_signing_key():
@@ -275,7 +275,7 @@ class SolanaWalletBackend(AgentWalletBackend):
         self.rpc_urls = rpc_url if isinstance(rpc_url, list) else [rpc_url]
         self.rpc_url = self.rpc_urls[0]
         self.commitment = commitment
-        self.network = network
+        self.network = normalize_solana_network(network)
         self.signer = signer
         self.address = final_address
         self.sign_only = sign_only
@@ -720,861 +720,6 @@ class SolanaWalletBackend(AgentWalletBackend):
         }
 
     @staticmethod
-    def _houdini_token_is_native(token: dict[str, Any]) -> bool:
-        chain = str(token.get("chain") or "").strip().lower()
-        symbol = str(token.get("symbol") or "").strip().lower()
-        address = str(token.get("address") or "").strip().lower()
-        return chain == "solana" and symbol == "sol" and address in {"", "sol", "native", "11111111111111111111111111111111", NATIVE_SOL_MINT.lower()}
-
-    def _normalize_houdini_private_preview_payload(
-        self,
-        *,
-        owner: str,
-        input_token: dict[str, Any],
-        output_token: dict[str, Any],
-        destination_address: str,
-        amount_ui: Decimal,
-        quote: dict[str, Any],
-        use_xmr: bool,
-    ) -> dict[str, Any]:
-        min_private = (
-            input_token.get("min_max_private")
-            if isinstance(input_token.get("min_max_private"), dict)
-            else {}
-        )
-        return {
-            "chain": "solana",
-            "network": self.network,
-            "mode": "preview",
-            "asset_type": "solana-private-swap",
-            "owner": owner,
-            "destination_address": destination_address,
-            "input_token_query": input_token.get("symbol"),
-            "output_token_query": output_token.get("symbol"),
-            "input_token_id": input_token.get("id"),
-            "output_token_id": output_token.get("id"),
-            "input_token_symbol": input_token.get("symbol"),
-            "output_token_symbol": output_token.get("symbol"),
-            "input_token_name": input_token.get("name"),
-            "output_token_name": output_token.get("name"),
-            "input_token_address": input_token.get("address"),
-            "output_token_address": output_token.get("address"),
-            "input_token_chain": input_token.get("chain"),
-            "output_token_chain": output_token.get("chain"),
-            "input_token_decimals": input_token.get("decimals"),
-            "output_token_decimals": output_token.get("decimals"),
-            "input_is_native": self._houdini_token_is_native(input_token),
-            "output_is_native": self._houdini_token_is_native(output_token),
-            "input_amount_ui": float(amount_ui),
-            "estimated_output_amount_ui": float(Decimal(str(quote.get("amountOut") or "0"))),
-            "estimated_output_amount_usd": quote.get("amountOutUsd"),
-            "input_private_min_ui": min_private.get("min"),
-            "input_private_max_ui": min_private.get("max"),
-            "private_duration_minutes": quote.get("duration"),
-            "quote_id": quote.get("quoteId"),
-            "quote_type": quote.get("type"),
-            "rewards_available": quote.get("rewardsAvailable"),
-            "anonymous": True,
-            "use_xmr": bool(use_xmr),
-            "can_send": self.get_capabilities().can_send_transaction,
-            "sign_only": self.sign_only,
-            "source": "houdini",
-        }
-
-    async def _wait_for_houdini_order_ready(
-        self,
-        *,
-        multi_id: str,
-        houdini_id: str,
-        timeout_seconds: float = 20.0,
-        poll_interval_seconds: float = 2.0,
-    ) -> dict[str, Any]:
-        deadline = asyncio.get_running_loop().time() + timeout_seconds
-        last_order: dict[str, Any] | None = None
-        while True:
-            status_payload = await houdini.fetch_multi_status(multi_id=multi_id)
-            orders = status_payload.get("orders")
-            if isinstance(orders, list):
-                for candidate in orders:
-                    if (
-                        isinstance(candidate, dict)
-                        and str(candidate.get("houdiniId") or "").strip() == houdini_id
-                    ):
-                        last_order = candidate
-                        break
-            if last_order is None:
-                raise WalletBackendError("Houdini order disappeared before funding could start.")
-            if str(last_order.get("statusLabel") or "").strip().upper() != "INITIALIZING":
-                return last_order
-            if asyncio.get_running_loop().time() >= deadline:
-                raise WalletBackendError(
-                    "Houdini order stayed in INITIALIZING too long. Generate a new preview and try again."
-                )
-            await asyncio.sleep(poll_interval_seconds)
-
-    async def _wait_for_houdini_single_order_ready(
-        self,
-        *,
-        houdini_id: str,
-        initial_order: dict[str, Any] | None = None,
-        timeout_seconds: float = 180.0,
-        poll_interval_seconds: float = 5.0,
-    ) -> dict[str, Any]:
-        deadline = asyncio.get_running_loop().time() + timeout_seconds
-        last_order: dict[str, Any] | None = initial_order if isinstance(initial_order, dict) else None
-        while True:
-            order = await houdini.fetch_order_status(houdini_id=houdini_id)
-            if isinstance(order, dict) and order:
-                last_order = order
-            if str(order.get("statusLabel") or "").strip().upper() != "INITIALIZING":
-                return order
-            if asyncio.get_running_loop().time() >= deadline:
-                details = {
-                    "houdini_id": houdini_id,
-                    "multi_id": str((last_order or {}).get("multiId") or "").strip() or None,
-                    "deposit_address": str((last_order or {}).get("depositAddress") or "").strip() or None,
-                    "order_status": str((last_order or {}).get("statusLabel") or "").strip() or "INITIALIZING",
-                    "order": last_order or order,
-                }
-                raise WalletBackendError(
-                    "Houdini order stayed in INITIALIZING too long. Keep the created order and retry execute after the deposit account is ready.",
-                    code="houdini_order_initializing_timeout",
-                    details=details,
-                )
-            await asyncio.sleep(poll_interval_seconds)
-
-    async def _wait_for_houdini_spl_deposit_ready(
-        self,
-        *,
-        deposit_address: str,
-        mint: str,
-        timeout_seconds: float = 180.0,
-        poll_interval_seconds: float = 5.0,
-    ) -> dict[str, Any]:
-        deadline = asyncio.get_running_loop().time() + timeout_seconds
-        while True:
-            account_info = await solana_rpc.fetch_account_info(
-                deposit_address,
-                rpc_url=self.rpc_urls,
-            )
-            if account_info:
-                recipient_mint = (
-                    (account_info or {})
-                    .get("data", {})
-                    .get("parsed", {})
-                    .get("info", {})
-                    .get("mint")
-                )
-                if recipient_mint and str(recipient_mint).strip() != mint:
-                    raise WalletBackendError(
-                        "Houdini deposit token account mint does not match the approved input token."
-                    )
-                return {
-                    "deposit_address": deposit_address,
-                    "account_info": account_info,
-                    "mint": recipient_mint,
-                }
-            if asyncio.get_running_loop().time() >= deadline:
-                raise WalletBackendError(
-                    "Houdini order was created, but the Solana deposit token account was not ready in time. Generate a new preview and try again.",
-                    code="houdini_deposit_not_ready",
-                    details={"deposit_address": deposit_address, "mint": mint},
-                )
-            await asyncio.sleep(poll_interval_seconds)
-
-    async def preview_solana_private_swap(
-        self,
-        *,
-        input_token: str,
-        output_token: str,
-        destination_address: str,
-        amount_ui: float,
-        use_xmr: bool = False,
-    ) -> dict[str, Any]:
-        if self.network != "mainnet":
-            raise WalletBackendError("Houdini private Solana swaps are only enabled for Solana mainnet.")
-        owner = await self.get_address()
-        if not owner:
-            raise WalletBackendError(
-                "No Solana wallet address configured. Set SOLANA_AGENT_PUBLIC_KEY or a signer."
-            )
-        if not isinstance(destination_address, str) or not destination_address.strip():
-            raise WalletBackendError("destination_address is required.")
-        destination_address = validate_solana_address(destination_address.strip())
-        if not isinstance(amount_ui, (int, float)) or amount_ui <= 0:
-            raise WalletBackendError("amount must be a positive number.")
-
-        amount_decimal = Decimal(str(amount_ui))
-        resolved_input = await houdini.resolve_cex_token(term=input_token, chain="solana")
-        resolved_output = await houdini.resolve_cex_token(term=output_token, chain="solana")
-        if str(resolved_input.get("id") or "") != str(resolved_output.get("id") or ""):
-            raise WalletBackendError(
-                "The initial Houdini Solana private route supports same-token private payouts only. "
-                "Use the same token for input and output, for example SOL->SOL or USDC->USDC."
-            )
-
-        private_quotes = await houdini.fetch_private_quotes(
-            from_token_id=str(resolved_input["id"]),
-            to_token_id=str(resolved_output["id"]),
-            amount_ui=amount_decimal,
-        )
-        best_quote = houdini.select_best_private_quote(private_quotes)
-        return self._normalize_houdini_private_preview_payload(
-            owner=owner,
-            input_token=resolved_input,
-            output_token=resolved_output,
-            destination_address=destination_address,
-            amount_ui=amount_decimal,
-            quote=best_quote,
-            use_xmr=use_xmr,
-        )
-
-    async def get_solana_private_swap_status(
-        self,
-        *,
-        multi_id: str | None = None,
-        houdini_id: str | None = None,
-    ) -> dict[str, Any]:
-        if self.network != "mainnet":
-            raise WalletBackendError("Houdini private Solana swaps are only enabled for Solana mainnet.")
-        normalized_multi_id = str(multi_id or "").strip()
-        normalized_houdini_id = str(houdini_id or "").strip()
-        if not normalized_multi_id and not normalized_houdini_id:
-            raise WalletBackendError("multi_id or houdini_id is required.")
-
-        if not normalized_multi_id:
-            selected_order = await houdini.fetch_order_status(houdini_id=normalized_houdini_id)
-            selected_status = str(selected_order.get("statusLabel") or "").strip() or None
-            terminal_statuses = {"FINISHED", "FAILED", "EXPIRED", "REFUNDED"}
-            return {
-                "chain": "solana",
-                "network": self.network,
-                "asset_type": "solana-private-swap",
-                "multi_id": None,
-                "order_count": 1,
-                "orders": [selected_order],
-                "selected_order": selected_order,
-                "selected_houdini_id": (
-                    str(selected_order.get("houdiniId") or "").strip() or normalized_houdini_id or None
-                ),
-                "selected_status": selected_status,
-                "all_terminal": bool(selected_status and selected_status.upper() in terminal_statuses),
-                "source": "houdini",
-            }
-
-        payload = await houdini.fetch_multi_status(multi_id=normalized_multi_id)
-        orders = payload.get("orders") if isinstance(payload.get("orders"), list) else []
-        selected_order = None
-        if normalized_houdini_id:
-            for order in orders:
-                if isinstance(order, dict) and str(order.get("houdiniId") or "").strip() == normalized_houdini_id:
-                    selected_order = order
-                    break
-            if selected_order is None:
-                raise WalletBackendError("houdini_id was not found inside the requested multi_id.")
-        elif len(orders) == 1 and isinstance(orders[0], dict):
-            selected_order = orders[0]
-
-        terminal_statuses = {"FINISHED", "FAILED", "EXPIRED", "REFUNDED"}
-        return {
-            "chain": "solana",
-            "network": self.network,
-            "asset_type": "solana-private-swap",
-            "multi_id": payload.get("multiId") or normalized_multi_id,
-            "order_count": len([item for item in orders if isinstance(item, dict)]),
-            "orders": orders,
-            "selected_order": selected_order,
-            "selected_houdini_id": (
-                str(selected_order.get("houdiniId") or "").strip()
-                if isinstance(selected_order, dict)
-                else None
-            ),
-            "selected_status": (
-                str(selected_order.get("statusLabel") or "").strip()
-                if isinstance(selected_order, dict)
-                else None
-            ),
-            "all_terminal": all(
-                isinstance(item, dict)
-                and str(item.get("statusLabel") or "").strip().upper() in terminal_statuses
-                for item in orders
-            )
-            if orders
-            else False,
-            "source": "houdini",
-        }
-
-    @staticmethod
-    def _pick_houdini_order_value(order: dict[str, Any], *keys: str) -> str:
-        for key in keys:
-            value = order.get(key)
-            if isinstance(value, str) and value.strip():
-                return value.strip()
-            if isinstance(value, (int, float, Decimal)):
-                text = str(value).strip()
-                if text:
-                    return text
-        return ""
-
-    @staticmethod
-    def _normalize_houdini_token_address(value: str) -> str:
-        normalized = str(value or "").strip()
-        if not normalized:
-            return ""
-        lowered = normalized.lower()
-        if lowered in {"sol", "native", "11111111111111111111111111111111"}:
-            return NATIVE_SOL_MINT.lower()
-        return lowered
-
-    def _validate_houdini_order_against_preview(
-        self,
-        *,
-        order: dict[str, Any],
-        preview: dict[str, Any],
-    ) -> dict[str, Any]:
-        if str(order.get("receiverAddress") or "").strip() != str(preview["destination_address"]):
-            raise WalletBackendError("Houdini order receiverAddress does not match the approved destination.")
-        if not bool(order.get("anonymous")):
-            raise WalletBackendError("Houdini order is not marked anonymous as required.")
-
-        checks: dict[str, Any] = {
-            "receiver_address": str(order.get("receiverAddress") or "").strip(),
-            "anonymous": bool(order.get("anonymous")),
-        }
-        warnings: list[str] = []
-
-        expected_input_id = str(preview.get("input_token_id") or "").strip()
-        order_input_id = self._pick_houdini_order_value(
-            order,
-            "from",
-            "fromId",
-            "inId",
-            "inputTokenId",
-            "fromTokenId",
-        )
-        if expected_input_id and order_input_id and order_input_id != expected_input_id:
-            raise WalletBackendError("Houdini order input token id does not match the approved token.")
-        checks["input_token_id"] = order_input_id or expected_input_id or None
-
-        expected_input_amount = Decimal(str(preview.get("input_amount_ui") or "0"))
-        order_input_amount = Decimal(
-            self._pick_houdini_order_value(order, "inAmount", "amountIn", "inputAmount") or "0"
-        )
-        if order_input_amount != expected_input_amount:
-            raise WalletBackendError("Houdini order input amount does not match the approved preview.")
-        checks["input_amount_ui"] = str(order_input_amount)
-
-        expected_output_id = str(preview.get("output_token_id") or "").strip()
-        order_output_id = self._pick_houdini_order_value(
-            order,
-            "to",
-            "toId",
-            "outId",
-            "outputTokenId",
-            "toTokenId",
-        )
-        if expected_output_id and order_output_id and order_output_id != expected_output_id:
-            raise WalletBackendError("Houdini order output token id does not match the approved token.")
-        checks["output_token_id"] = order_output_id or expected_output_id or None
-
-        expected_input_address = self._normalize_houdini_token_address(
-            str(preview.get("input_token_address") or "")
-        )
-        order_input_address = self._normalize_houdini_token_address(
-            self._pick_houdini_order_value(
-                order,
-                "fromAddress",
-                "inAddress",
-                "inputTokenAddress",
-                "fromTokenAddress",
-            )
-        )
-        if expected_input_address and order_input_address and order_input_address != expected_input_address:
-            raise WalletBackendError("Houdini order input token address does not match the approved token.")
-        checks["input_token_address"] = order_input_address or expected_input_address or None
-
-        expected_output_address = self._normalize_houdini_token_address(
-            str(preview.get("output_token_address") or "")
-        )
-        order_output_address = self._normalize_houdini_token_address(
-            self._pick_houdini_order_value(
-                order,
-                "toAddress",
-                "outAddress",
-                "outputTokenAddress",
-                "toTokenAddress",
-            )
-        )
-        if expected_output_address and order_output_address and order_output_address != expected_output_address:
-            raise WalletBackendError("Houdini order output token address does not match the approved token.")
-        checks["output_token_address"] = order_output_address or expected_output_address or None
-
-        expected_input_symbol = str(preview.get("input_token_symbol") or "").strip().upper()
-        order_input_symbol = self._pick_houdini_order_value(order, "inSymbol", "fromSymbol").upper()
-        if expected_input_symbol and order_input_symbol and order_input_symbol != expected_input_symbol:
-            warnings.append(
-                "Houdini order input token symbol differs from the approved preview display symbol."
-            )
-        checks["input_token_symbol"] = order_input_symbol or expected_input_symbol or None
-
-        expected_output_symbol = str(preview.get("output_token_symbol") or "").strip().upper()
-        order_output_symbol = self._pick_houdini_order_value(order, "outSymbol", "toSymbol").upper()
-        if expected_output_symbol and order_output_symbol and order_output_symbol != expected_output_symbol:
-            warnings.append(
-                "Houdini order output token symbol differs from the approved preview display symbol."
-            )
-        checks["output_token_symbol"] = order_output_symbol or expected_output_symbol or None
-
-        return {
-            "validated": True,
-            "checks": checks,
-            "warnings": warnings,
-        }
-
-    def _validate_houdini_order_output_against_preview(
-        self,
-        *,
-        order: dict[str, Any],
-        preview: dict[str, Any],
-    ) -> dict[str, Any]:
-        expected_output = Decimal(str(preview["estimated_output_amount_ui"]))
-        order_output = Decimal(
-            self._pick_houdini_order_value(order, "outAmount", "amountOut", "outputAmount") or "0"
-        )
-        tolerance = (
-            expected_output * Decimal(HOUDINI_PRIVATE_OUTPUT_DRIFT_BPS) / Decimal(10_000)
-        )
-        minimum_allowed = expected_output - tolerance
-        if order_output < minimum_allowed:
-            raise WalletBackendError(
-                "Houdini order output fell materially below the approved preview. Generate a new preview and approval before execute.",
-                code="private_swap_quote_changed",
-                details={
-                    "approved_estimated_output_amount_ui": str(expected_output),
-                    "order_output_amount_ui": str(order_output),
-                    "minimum_allowed_output_amount_ui": str(minimum_allowed),
-                    "allowed_drift_bps": HOUDINI_PRIVATE_OUTPUT_DRIFT_BPS,
-                },
-            )
-        warnings: list[str] = []
-        if order_output < expected_output:
-            warnings.append(
-                "Houdini order output drifted slightly below the approved preview but stayed within the allowed tolerance."
-            )
-        return {
-            "validated": True,
-            "approved_estimated_output_amount_ui": str(expected_output),
-            "order_output_amount_ui": str(order_output),
-            "minimum_allowed_output_amount_ui": str(minimum_allowed),
-            "allowed_drift_bps": HOUDINI_PRIVATE_OUTPUT_DRIFT_BPS,
-            "warnings": warnings,
-        }
-
-    async def _send_houdini_exact_spl_deposit(
-        self,
-        *,
-        recipient_token_account: str,
-        mint: str,
-        amount_raw: int,
-        decimals: int,
-    ) -> dict[str, Any]:
-        if not self.signer:
-            raise WalletBackendError("Solana signer is not configured.")
-
-        sender = await self.get_address()
-        if not sender:
-            raise WalletBackendError(
-                "No Solana wallet address configured. Set SOLANA_AGENT_PUBLIC_KEY or a signer."
-            )
-
-        recipient_token_account = validate_solana_address(recipient_token_account)
-        mint = validate_solana_mint(mint)
-        if amount_raw <= 0:
-            raise WalletBackendError("Houdini SPL deposit amount must be greater than zero.")
-
-        try:
-            from solders.hash import Hash
-            from solders.keypair import Keypair
-            from solders.message import Message
-            from solders.pubkey import Pubkey
-            from solders.transaction import Transaction
-            from spl.token.instructions import (
-                TransferCheckedParams,
-                get_associated_token_address,
-                transfer_checked,
-            )
-        except ImportError as exc:
-            raise WalletBackendError(
-                "solana and solders packages are required for SPL token transfers."
-            ) from exc
-
-        sender_pubkey = Pubkey.from_string(sender)
-        mint_pubkey = Pubkey.from_string(mint)
-        token_program_id = await self._resolve_token_program_id(mint)
-        token_program_pubkey = Pubkey.from_string(token_program_id)
-        sender_token_account = str(
-            get_associated_token_address(
-                sender_pubkey,
-                mint_pubkey,
-                token_program_id=token_program_pubkey,
-            )
-        )
-        sender_token_account_exists = await solana_rpc.account_exists(
-            sender_token_account,
-            rpc_url=self.rpc_urls,
-        )
-        if not sender_token_account_exists:
-            raise WalletBackendError("Sender token account does not exist for this mint.")
-        original_deposit_address = recipient_token_account
-        await self._wait_for_houdini_spl_deposit_ready(
-            deposit_address=recipient_token_account,
-            mint=mint,
-        )
-
-        sender_balance = await solana_rpc.fetch_token_account_balance(
-            sender_token_account,
-            rpc_url=self.rpc_urls,
-        )
-        sender_raw_balance = int(sender_balance.get("amount") or 0)
-        if amount_raw > sender_raw_balance:
-            raise WalletBackendError("Insufficient token balance for this private transfer.")
-
-        latest_blockhash = await solana_rpc.fetch_latest_blockhash(
-            rpc_url=self.rpc_urls,
-            commitment=self.commitment,
-        )
-        blockhash = Hash.from_string(str(latest_blockhash["blockhash"]))
-        keypair = Keypair.from_bytes(self.signer.export_keypair_bytes())
-        message = Message.new_with_blockhash(
-            [
-                transfer_checked(
-                    TransferCheckedParams(
-                        program_id=token_program_pubkey,
-                        source=Pubkey.from_string(sender_token_account),
-                        mint=mint_pubkey,
-                        dest=Pubkey.from_string(recipient_token_account),
-                        owner=sender_pubkey,
-                        amount=amount_raw,
-                        decimals=decimals,
-                        signers=[],
-                    )
-                )
-            ],
-            sender_pubkey,
-            blockhash,
-        )
-        transaction = Transaction([keypair], message, blockhash)
-        submitted = await solana_rpc.send_transaction(
-            transaction_base64=encode_transaction_base64(bytes(transaction)),
-            rpc_url=self.rpc_urls,
-        )
-        signature = submitted.get("signature")
-        status = None
-        confirmed = False
-        if isinstance(signature, str) and signature:
-            status = await solana_rpc.wait_for_confirmation(
-                signature=signature,
-                rpc_url=self.rpc_urls,
-            )
-            confirmed = status is not None
-
-        return {
-            "chain": "solana",
-            "network": self.network,
-            "mode": "execute",
-            "asset_type": "spl",
-            "from_address": sender,
-            "to_address": recipient_token_account,
-            "requested_deposit_address": original_deposit_address,
-            "deposit_address_interpretation": "token_account",
-            "mint": mint,
-            "token_program_id": token_program_id,
-            "sender_token_account": sender_token_account,
-            "recipient_token_account": recipient_token_account,
-            "recipient_token_account_exists_before": True,
-            "recipient_token_account_created": False,
-            "amount_ui": float(Decimal(amount_raw) / (Decimal(10) ** decimals)),
-            "amount_raw": amount_raw,
-            "decimals": decimals,
-            "signature": signature,
-            "broadcasted": bool(signature),
-            "confirmed": confirmed,
-            "confirmation_status": status.get("confirmationStatus") if status else None,
-            "slot": status.get("slot") if status else None,
-            "sign_only": self.sign_only,
-            "source": "solana-rpc",
-            "execute_response": submitted,
-        }
-
-    async def execute_solana_private_swap(
-        self,
-        *,
-        input_token: str,
-        output_token: str,
-        destination_address: str,
-        amount_ui: float,
-        use_xmr: bool = False,
-        approved_preview: dict[str, Any] | None = None,
-        existing_order: dict[str, Any] | None = None,
-    ) -> dict[str, Any]:
-        if self.network != "mainnet":
-            raise WalletBackendError("Houdini private Solana swaps are only enabled for Solana mainnet.")
-        if not self.signer:
-            raise WalletBackendError("Solana signer is not configured.")
-        if self.sign_only:
-            raise WalletBackendError(
-                "This wallet backend is in sign-only mode. Disable sign_only to broadcast transactions."
-            )
-
-        preview = (
-            dict(approved_preview)
-            if isinstance(approved_preview, dict)
-            else await self.preview_solana_private_swap(
-                input_token=input_token,
-                output_token=output_token,
-                destination_address=destination_address,
-                amount_ui=amount_ui,
-                use_xmr=use_xmr,
-            )
-        )
-        owner = str(preview.get("owner") or await self.get_address() or "").strip()
-        if not owner:
-            raise WalletBackendError("No Solana wallet address configured for Houdini execution.")
-
-        quote_id = str(preview.get("quote_id") or "").strip()
-        if not quote_id:
-            raise WalletBackendError("Approved private swap preview is missing quote_id.")
-
-        if isinstance(existing_order, dict) and existing_order:
-            create_payload = dict(existing_order)
-            order = (
-                create_payload.get("order")
-                if isinstance(create_payload.get("order"), dict)
-                else create_payload
-            )
-            if not isinstance(order, dict):
-                raise WalletBackendError("Stored Houdini private swap order is invalid.")
-            multi_id = str(create_payload.get("multi_id") or create_payload.get("multiId") or order.get("multiId") or "").strip() or None
-            houdini_id = str(
-                create_payload.get("houdini_id")
-                or create_payload.get("houdiniId")
-                or order.get("houdiniId")
-                or ""
-            ).strip()
-            if not houdini_id:
-                raise WalletBackendError("Stored Houdini private swap order is missing houdini_id.")
-            latest_order = await houdini.fetch_order_status(houdini_id=houdini_id)
-            if isinstance(latest_order, dict) and latest_order:
-                order = latest_order
-
-            order_validation = self._validate_houdini_order_against_preview(
-                order=order,
-                preview=preview,
-            )
-            output_validation = self._validate_houdini_order_output_against_preview(
-                order=order,
-                preview=preview,
-            )
-            input_decimals = int(preview.get("input_token_decimals") or (9 if bool(preview.get("input_is_native")) else 0))
-            input_amount_raw = int(
-                (Decimal(str(preview["input_amount_ui"])) * (Decimal(10) ** input_decimals))
-                .to_integral_value()
-            )
-            deposit_address = str(order.get("depositAddress") or "").strip()
-            if not deposit_address:
-                raise WalletBackendError("Houdini private swap response is missing depositAddress.")
-
-            if bool(preview.get("input_is_native")):
-                funding_result = await self.send_native_transfer(
-                    recipient=deposit_address,
-                    amount_native=float(Decimal(str(preview["input_amount_ui"]))),
-                )
-            else:
-                try:
-                    funding_result = await self._send_houdini_exact_spl_deposit(
-                        recipient_token_account=deposit_address,
-                        mint=str(preview.get("input_token_address") or "").strip(),
-                        amount_raw=input_amount_raw,
-                        decimals=input_decimals,
-                    )
-                except WalletBackendError as exc:
-                    if exc.code == "houdini_deposit_not_ready":
-                        details = dict(exc.details or {})
-                        details.update(
-                            {
-                                "multi_id": multi_id,
-                                "houdini_id": houdini_id,
-                                "deposit_address": deposit_address,
-                                "order_status": order.get("statusLabel"),
-                                "order": order,
-                                "input_token_address": str(preview.get("input_token_address") or "").strip(),
-                                "input_amount_raw": str(input_amount_raw),
-                                "input_decimals": input_decimals,
-                            }
-                        )
-                        raise WalletBackendError(
-                            "Houdini order exists, but its Solana deposit account is not ready yet. Retry continue for the existing order instead of generating a new preview.",
-                            code="houdini_deposit_not_ready",
-                            details=details,
-                        ) from exc
-                    raise
-
-            signature = str(funding_result.get("signature") or "").strip() or None
-            confirmed = bool(funding_result.get("confirmed"))
-
-            return {
-                "chain": "solana",
-                "network": self.network,
-                "mode": "execute",
-                "asset_type": "solana-private-swap",
-                "owner": owner,
-                "destination_address": str(preview["destination_address"]),
-                "input_token_id": preview["input_token_id"],
-                "output_token_id": preview["output_token_id"],
-                "input_token_symbol": preview["input_token_symbol"],
-                "output_token_symbol": preview["output_token_symbol"],
-                "input_token_address": preview["input_token_address"],
-                "output_token_address": preview["output_token_address"],
-                "input_is_native": bool(preview.get("input_is_native")),
-                "input_amount_ui": preview["input_amount_ui"],
-                "estimated_output_amount_ui": preview["estimated_output_amount_ui"],
-                "private_duration_minutes": order.get("eta") or preview.get("private_duration_minutes"),
-                "multi_id": multi_id,
-                "houdini_id": houdini_id,
-                "deposit_address": deposit_address,
-                "order_status": order.get("statusLabel"),
-                "order": order,
-                "signature": signature,
-                "broadcasted": bool(signature),
-                "confirmed": confirmed,
-                "confirmation_status": funding_result.get("confirmation_status"),
-                "slot": funding_result.get("slot"),
-                "verification": {
-                    "verified": True,
-                    "deposit_address": deposit_address,
-                    "amount_raw": str(input_amount_raw),
-                    "is_native_input": bool(preview.get("input_is_native")),
-                    "token_mint": (
-                        None
-                        if bool(preview.get("input_is_native"))
-                        else str(preview.get("input_token_address") or "").strip()
-                    ),
-                    "quote_bound_single_exchange": True,
-                },
-                "simulation": None,
-                "provider_order_validation": order_validation,
-                "output_validation": output_validation,
-                "funding_transfer": funding_result,
-                "execute_response": funding_result.get("execute_response"),
-                "status_tracking": {
-                    "multi_id": multi_id,
-                    "houdini_id": houdini_id,
-                    "poll_status_tool": "get_solana_private_swap_status",
-                },
-                "source": "houdini",
-                "execution_state": "funding_submitted",
-            }
-        else:
-            try:
-                create_payload = await houdini.create_exchange(
-                    quote_id=quote_id,
-                    destination_address=str(preview["destination_address"]),
-                )
-            except ProviderError as exc:
-                details = dict(exc.details or {})
-                gateway_error = details.get("error") if isinstance(details.get("error"), dict) else None
-                if isinstance(gateway_error, dict) and str(gateway_error.get("code") or "").strip() == "RATE_LIMIT_EXCEEDED":
-                    retry_after = gateway_error.get("retryAfter")
-                    raise WalletBackendError(
-                        "Houdini exchange create is rate-limited right now. Wait and retry execute without generating a new preview.",
-                        code="houdini_exchange_rate_limited",
-                        details={
-                            "retry_after": retry_after,
-                            "quote_id": quote_id,
-                            "destination_address": str(preview["destination_address"]),
-                            "provider": getattr(exc, "provider", "houdini"),
-                            "upstream_error": gateway_error,
-                        },
-                    ) from exc
-                raise
-            order = create_payload.get("order") if isinstance(create_payload.get("order"), dict) else create_payload
-            if not isinstance(order, dict):
-                raise WalletBackendError("Houdini returned no order object for the private swap.")
-            if isinstance(order.get("error"), dict):
-                error = order["error"]
-                raise WalletBackendError(
-                    f"Houdini rejected the private swap request: {error.get('message') or 'unknown error'}.",
-                    code=str(error.get("code") or "").strip() or None,
-                    details=error,
-                )
-
-            multi_id = str(create_payload.get("multiId") or order.get("multiId") or "").strip() or None
-            houdini_id = str(order.get("houdiniId") or create_payload.get("houdiniId") or "").strip()
-            if not houdini_id:
-                raise WalletBackendError("Houdini private swap response is missing the order identifier.")
-            deposit_address = str(order.get("depositAddress") or "").strip()
-            if not deposit_address:
-                raise WalletBackendError("Houdini private swap response is missing depositAddress.")
-
-            order_validation = self._validate_houdini_order_against_preview(
-                order=order,
-                preview=preview,
-            )
-            output_validation = self._validate_houdini_order_output_against_preview(
-                order=order,
-                preview=preview,
-            )
-
-            return {
-                "chain": "solana",
-                "network": self.network,
-                "mode": "execute",
-                "asset_type": "solana-private-swap",
-                "owner": owner,
-                "destination_address": str(preview["destination_address"]),
-                "input_token_id": preview["input_token_id"],
-                "output_token_id": preview["output_token_id"],
-                "input_token_symbol": preview["input_token_symbol"],
-                "output_token_symbol": preview["output_token_symbol"],
-                "input_token_address": preview["input_token_address"],
-                "output_token_address": preview["output_token_address"],
-                "input_is_native": bool(preview.get("input_is_native")),
-                "input_amount_ui": preview["input_amount_ui"],
-                "estimated_output_amount_ui": preview["estimated_output_amount_ui"],
-                "private_duration_minutes": order.get("eta") or preview.get("private_duration_minutes"),
-                "multi_id": multi_id,
-                "houdini_id": houdini_id,
-                "deposit_address": deposit_address,
-                "order_status": order.get("statusLabel"),
-                "order": order,
-                "provider_order_validation": order_validation,
-                "output_validation": output_validation,
-                "status_tracking": {
-                    "multi_id": multi_id,
-                    "houdini_id": houdini_id,
-                    "poll_status_tool": "get_solana_private_swap_status",
-                },
-                "source": "houdini",
-                "execution_state": "awaiting_deposit_funding",
-                "next_step": "Call continue_solana_private_swap with the same approved private swap context to submit the funding transfer.",
-            }
-
-    async def continue_solana_private_swap(
-        self,
-        *,
-        approved_preview: dict[str, Any],
-        existing_order: dict[str, Any],
-    ) -> dict[str, Any]:
-        return await self.execute_solana_private_swap(
-            input_token=str(approved_preview.get("input_token_query") or approved_preview.get("input_token_symbol") or ""),
-            output_token=str(approved_preview.get("output_token_query") or approved_preview.get("output_token_symbol") or ""),
-            destination_address=str(approved_preview.get("destination_address") or ""),
-            amount_ui=float(approved_preview.get("input_amount_ui") or 0),
-            use_xmr=bool(approved_preview.get("use_xmr", False)),
-            approved_preview=approved_preview,
-            existing_order=existing_order,
-        )
-
     async def preview_solana_lifi_cross_chain_swap(
         self,
         *,
@@ -2422,109 +1567,39 @@ class SolanaWalletBackend(AgentWalletBackend):
                 if not isinstance(platform, str) or not platform.strip():
                     raise WalletBackendError("Each platform must be a non-empty string.")
                 platform_filter.append(platform.strip())
-        data = await jupiter.fetch_portfolio_positions(
-            address=wallet_address,
-            platforms=platform_filter,
-        )
-        positions = data.get("positions")
-        if not isinstance(positions, list):
-            positions = data.get("data") if isinstance(data.get("data"), list) else []
-        return {
-            "chain": "solana",
-            "network": self.network,
-            "address": wallet_address,
-            "platforms": platform_filter or [],
-            "position_count": len(positions),
-            "positions": positions,
-            "raw": data,
-            "source": "jupiter-portfolio",
-        }
-
-    async def get_jupiter_staked_jup(self, address: str | None = None) -> dict[str, Any]:
-        self._require_mainnet_jupiter("Jupiter staked JUP")
-        wallet_address = address or self.address
-        if not wallet_address:
-            raise WalletBackendError(
-                "No Solana wallet address configured. Set SOLANA_AGENT_PUBLIC_KEY or a signer."
-            )
-        wallet_address = validate_solana_address(wallet_address)
-        data = await jupiter.fetch_staked_jup(address=wallet_address)
-        return {
-            "chain": "solana",
-            "network": self.network,
-            "address": wallet_address,
-            "raw": data,
-            "source": "jupiter-portfolio",
-        }
-
-    async def get_jupiter_earn_tokens(self) -> dict[str, Any]:
-        self._require_mainnet_jupiter("Jupiter Earn")
-        data = await jupiter.fetch_earn_tokens()
-        tokens = data.get("tokens")
-        if not isinstance(tokens, list):
-            tokens = []
-        return {
-            "chain": "solana",
-            "network": self.network,
-            "token_count": len(tokens),
-            "tokens": tokens,
-            "raw": data,
-            "source": "jupiter-lend",
-        }
-
-    async def get_jupiter_earn_positions(
-        self,
-        users: list[str] | None = None,
-    ) -> dict[str, Any]:
-        self._require_mainnet_jupiter("Jupiter Earn")
-        resolved_users = users or [self.address]
-        if not resolved_users or any(user is None for user in resolved_users):
-            raise WalletBackendError("At least one wallet address is required for Earn positions.")
-        normalized_users = [validate_solana_address(str(user)) for user in resolved_users]
-        data = await jupiter.fetch_earn_positions(users=normalized_users)
+        data = await jupiter.fetch_portfolio_positions(
+            address=wallet_address,
+            platforms=platform_filter,
+        )
         positions = data.get("positions")
         if not isinstance(positions, list):
-            positions = []
+            positions = data.get("data") if isinstance(data.get("data"), list) else []
         return {
             "chain": "solana",
             "network": self.network,
-            "users": normalized_users,
+            "address": wallet_address,
+            "platforms": platform_filter or [],
             "position_count": len(positions),
             "positions": positions,
             "raw": data,
-            "source": "jupiter-lend",
+            "source": "jupiter-portfolio",
         }
 
-    async def get_jupiter_earn_earnings(
-        self,
-        user: str | None = None,
-        positions: list[str] | None = None,
-    ) -> dict[str, Any]:
-        self._require_mainnet_jupiter("Jupiter Earn")
-        wallet_address = user or self.address
+    async def get_jupiter_staked_jup(self, address: str | None = None) -> dict[str, Any]:
+        self._require_mainnet_jupiter("Jupiter staked JUP")
+        wallet_address = address or self.address
         if not wallet_address:
             raise WalletBackendError(
-                "A wallet address is required for Jupiter Earn earnings lookup."
+                "No Solana wallet address configured. Set SOLANA_AGENT_PUBLIC_KEY or a signer."
             )
-        if not positions:
-            raise WalletBackendError("positions must include at least one Earn position address.")
         wallet_address = validate_solana_address(wallet_address)
-        normalized_positions = [validate_solana_address(str(position)) for position in positions]
-        data = await jupiter.fetch_earn_earnings(
-            user=wallet_address,
-            positions=normalized_positions,
-        )
-        earnings = data.get("earnings")
-        if not isinstance(earnings, list):
-            earnings = []
+        data = await jupiter.fetch_staked_jup(address=wallet_address)
         return {
             "chain": "solana",
             "network": self.network,
-            "user": wallet_address,
-            "positions": normalized_positions,
-            "earnings": earnings,
+            "address": wallet_address,
             "raw": data,
-            "source": "jupiter-lend",
+            "source": "jupiter-portfolio",
         }
 
     async def get_flash_trade_markets(
@@ -3217,6 +2292,440 @@ class SolanaWalletBackend(AgentWalletBackend):
             "source": "kamino",
         }
 
+    async def get_kamino_open_positions(self, user: str | None = None) -> dict[str, Any]:
+        self._require_mainnet_kamino("Kamino lending")
+        wallet_address = user or self.address
+        if not wallet_address:
+            raise WalletBackendError("A wallet address is required for Kamino position lookup.")
+        wallet_address = validate_solana_address(wallet_address)
+
+        markets_snapshot = await self.get_kamino_lend_markets()
+        markets = markets_snapshot.get("markets")
+        if not isinstance(markets, list):
+            markets = []
+
+        lookup_errors: list[dict[str, Any]] = []
+        semaphore = asyncio.Semaphore(KAMINO_OPEN_POSITIONS_SCAN_CONCURRENCY)
+
+        def _market_address(entry: Any) -> str:
+            return _kamino_entry_address(entry, "lendingMarket", "market", "address")
+
+        def _market_name(entry: Any) -> str | None:
+            if isinstance(entry, dict):
+                value = entry.get("name")
+                if isinstance(value, str) and value.strip():
+                    return value.strip()
+            return None
+
+        async def _fetch_market_obligations(
+            market_entry: dict[str, Any],
+        ) -> tuple[dict[str, Any], dict[str, Any]] | None:
+            market_address = _market_address(market_entry)
+            if not market_address:
+                return None
+            try:
+                async with semaphore:
+                    obligations_snapshot = await self.get_kamino_lend_user_obligations(
+                        market=market_address,
+                        user=wallet_address,
+                    )
+            except (ProviderError, WalletBackendError) as exc:
+                lookup_errors.append(
+                    {
+                        "stage": "market_obligations",
+                        "market": market_address,
+                        "market_name": _market_name(market_entry),
+                        "error": str(exc),
+                    }
+                )
+                return None
+            if int(obligations_snapshot.get("obligation_count") or 0) <= 0:
+                return None
+            return market_entry, obligations_snapshot
+
+        market_results = await asyncio.gather(
+            *[
+                _fetch_market_obligations(market_entry)
+                for market_entry in markets
+                if isinstance(market_entry, dict)
+            ]
+        )
+        active_markets = [result for result in market_results if result is not None]
+        discovered_obligation_count = sum(
+            int(obligations_snapshot.get("obligation_count") or 0)
+            for _, obligations_snapshot in active_markets
+        )
+
+        try:
+            reward_snapshot = await self.get_kamino_lend_user_rewards(user=wallet_address)
+        except (ProviderError, WalletBackendError) as exc:
+            lookup_errors.append(
+                {
+                    "stage": "rewards",
+                    "user": wallet_address,
+                    "error": str(exc),
+                }
+            )
+            reward_snapshot = {
+                "chain": "solana",
+                "network": self.network,
+                "user": wallet_address,
+                "reward_count": 0,
+                "rewards": [],
+                "avg_base_apy": None,
+                "avg_boosted_apy": None,
+                "avg_max_apy": None,
+                "source": "kamino",
+            }
+        reward_items = reward_snapshot.get("rewards")
+        if not isinstance(reward_items, list):
+            reward_items = []
+
+        positions: list[dict[str, Any]] = []
+        markets_with_positions: list[dict[str, Any]] = []
+        total_collateral_value = Decimal("0")
+        total_borrow_value = Decimal("0")
+
+        for market_entry, obligations_snapshot in active_markets:
+            market_address = _market_address(market_entry)
+            market_name = _market_name(market_entry)
+            market_description = (
+                market_entry.get("description")
+                if isinstance(market_entry, dict) and isinstance(market_entry.get("description"), str)
+                else None
+            )
+            markets_with_positions.append(
+                {
+                    "market": market_address,
+                    "market_name": market_name,
+                    "obligation_count": int(obligations_snapshot.get("obligation_count") or 0),
+                }
+            )
+
+            try:
+                reserve_snapshot = await self.get_kamino_lend_market_reserves(market=market_address)
+            except (ProviderError, WalletBackendError) as exc:
+                lookup_errors.append(
+                    {
+                        "stage": "market_reserves",
+                        "market": market_address,
+                        "market_name": market_name,
+                        "error": str(exc),
+                    }
+                )
+                reserve_snapshot = {
+                    "chain": "solana",
+                    "network": self.network,
+                    "market": market_address,
+                    "reserve_count": 0,
+                    "reserves": [],
+                    "source": "kamino",
+                }
+            reserves = reserve_snapshot.get("reserves")
+            if not isinstance(reserves, list):
+                reserves = []
+            reserve_by_address = {
+                address: reserve
+                for reserve in reserves
+                if isinstance(reserve, dict)
+                and (address := _kamino_entry_address(reserve, "reserve"))
+            }
+            reserve_by_mint = {
+                mint: reserve
+                for reserve in reserves
+                if isinstance(reserve, dict)
+                and isinstance((mint := reserve.get("liquidityTokenMint")), str)
+                and mint.strip()
+            }
+            reserve_by_symbol = {
+                symbol.upper(): reserve
+                for reserve in reserves
+                if isinstance(reserve, dict)
+                and isinstance((symbol := reserve.get("liquidityToken")), str)
+                and symbol.strip()
+            }
+
+            def _reward_metrics_for_reserve(
+                *,
+                reserve_address: str | None,
+                side: str,
+            ) -> list[dict[str, Any]]:
+                if not reserve_address:
+                    return []
+                reserve_key = "depositReserve" if side == "deposit" else "borrowReserve"
+                metrics: list[dict[str, Any]] = []
+                for reward in reward_items:
+                    if not isinstance(reward, dict):
+                        continue
+                    reward_market = _kamino_entry_address(reward, "market")
+                    if reward_market and reward_market != market_address:
+                        continue
+                    reward_reserve = _kamino_entry_address(reward, reserve_key)
+                    if reward_reserve != reserve_address:
+                        continue
+                    metrics.append(
+                        {
+                            "reward_mint": _kamino_entry_address(reward, "rewardMint", "rewardToken"),
+                            "tokens_earned": reward.get("tokensEarned"),
+                            "tokens_per_second": reward.get("tokensPerSecond"),
+                            "base_apy": reward.get("baseApy"),
+                            "boosted_apy": reward.get("boostedApy"),
+                            "max_apy": reward.get("maxApy"),
+                            "usd_amount": reward.get("usdAmount"),
+                            "usd_amount_boosted": reward.get("usdAmountBoosted"),
+                            "staking_boost": reward.get("stakingBoost"),
+                            "effective_staking_boost": reward.get("effectiveStakingBoost"),
+                            "last_calculated": reward.get("lastCalculated"),
+                        }
+                    )
+                return metrics
+
+            obligations = obligations_snapshot.get("obligations")
+            if not isinstance(obligations, list):
+                obligations = []
+            for obligation in obligations:
+                if not isinstance(obligation, dict):
+                    continue
+                obligation_address = _kamino_entry_address(
+                    obligation,
+                    "obligationAddress",
+                    "loanId",
+                    "address",
+                )
+                if not obligation_address:
+                    continue
+                try:
+                    loan_data = await kamino.fetch_lend_loan_info(
+                        obligation=obligation_address,
+                        network=self.network,
+                    )
+                except ProviderError as exc:
+                    lookup_errors.append(
+                        {
+                            "stage": "loan_info",
+                            "market": market_address,
+                            "market_name": market_name,
+                            "obligation_address": obligation_address,
+                            "error": str(exc),
+                        }
+                    )
+                    continue
+
+                loan_info = loan_data.get("loanInfo")
+                if not isinstance(loan_info, dict):
+                    loan_info = {}
+                collateral = loan_info.get("collateral")
+                if not isinstance(collateral, dict):
+                    collateral = {}
+                debt = loan_info.get("debt")
+                if not isinstance(debt, dict):
+                    debt = {}
+                deposit_entries = collateral.get("deposits")
+                if not isinstance(deposit_entries, list):
+                    deposit_entries = []
+                borrow_entries = debt.get("borrows")
+                if not isinstance(borrow_entries, list):
+                    borrow_entries = []
+
+                state = obligation.get("state")
+                if not isinstance(state, dict):
+                    state = {}
+                state_deposits = [
+                    entry
+                    for entry in state.get("deposits", [])
+                    if isinstance(entry, dict)
+                    and (_coerce_decimal(entry.get("depositedAmount")) or Decimal("0")) > 0
+                ]
+                state_borrows = [
+                    entry
+                    for entry in state.get("borrows", [])
+                    if isinstance(entry, dict)
+                    and (
+                        (_coerce_decimal(entry.get("borrowedAmountSf")) or Decimal("0")) > 0
+                        or (_coerce_decimal(entry.get("marketValueSf")) or Decimal("0")) > 0
+                    )
+                ]
+
+                def _match_reserve(
+                    *,
+                    token_mint: str | None,
+                    token_name: str | None,
+                    fallback_entry: Any,
+                    reserve_key: str,
+                ) -> tuple[str | None, dict[str, Any] | None]:
+                    fallback_address = _kamino_entry_address(fallback_entry, reserve_key)
+                    if fallback_address and fallback_address in reserve_by_address:
+                        return fallback_address, reserve_by_address[fallback_address]
+                    if token_mint and token_mint in reserve_by_mint:
+                        reserve_entry = reserve_by_mint[token_mint]
+                        return _kamino_entry_address(reserve_entry, "reserve") or None, reserve_entry
+                    symbol = token_name.strip().upper() if isinstance(token_name, str) and token_name.strip() else None
+                    if symbol and symbol in reserve_by_symbol:
+                        reserve_entry = reserve_by_symbol[symbol]
+                        return _kamino_entry_address(reserve_entry, "reserve") or None, reserve_entry
+                    return fallback_address or None, None
+
+                def _enrich_position_entries(
+                    *,
+                    entries: list[dict[str, Any]],
+                    state_entries: list[dict[str, Any]],
+                    side: str,
+                ) -> list[dict[str, Any]]:
+                    enriched: list[dict[str, Any]] = []
+                    reserve_key = "depositReserve" if side == "deposit" else "borrowReserve"
+                    for index, entry in enumerate(entries):
+                        if not isinstance(entry, dict):
+                            continue
+                        token_mint = entry.get("tokenMint")
+                        token_name = entry.get("tokenName")
+                        fallback_entry = state_entries[index] if index < len(state_entries) else None
+                        reserve_address, reserve_metrics = _match_reserve(
+                            token_mint=token_mint if isinstance(token_mint, str) else None,
+                            token_name=token_name if isinstance(token_name, str) else None,
+                            fallback_entry=fallback_entry,
+                            reserve_key=reserve_key,
+                        )
+                        reward_metrics = _reward_metrics_for_reserve(
+                            reserve_address=reserve_address,
+                            side=side,
+                        )
+                        enriched.append(
+                            {
+                                "reserve": reserve_address,
+                                "token_mint": token_mint,
+                                "token_name": token_name,
+                                "token_amount": entry.get("tokenAmount"),
+                                "token_value_usd": entry.get("tokenValue"),
+                                "token_price_usd": entry.get("tokenPrice"),
+                                "max_ltv": entry.get("maxLtv"),
+                                "liquidation_ltv": entry.get("liquidationLtv"),
+                                "max_withdrawable_amount": entry.get("maxWithdrawableAmount"),
+                                "max_withdrawable_value_usd": entry.get("maxWithdrawableValue"),
+                                "max_borrowable_amount": entry.get("maxBorrowableAmount"),
+                                "max_borrowable_value_usd": entry.get("maxBorrowableValue"),
+                                "borrow_factor": entry.get("borrowFactor"),
+                                "reserve_supply_apy": (
+                                    reserve_metrics.get("supplyApy")
+                                    if isinstance(reserve_metrics, dict)
+                                    else None
+                                ),
+                                "reserve_borrow_apy": (
+                                    reserve_metrics.get("borrowApy")
+                                    if isinstance(reserve_metrics, dict)
+                                    else None
+                                ),
+                                "reserve_max_ltv": (
+                                    reserve_metrics.get("maxLtv")
+                                    if isinstance(reserve_metrics, dict)
+                                    else None
+                                ),
+                                "reward_metrics": reward_metrics,
+                                "reward_count": len(reward_metrics),
+                            }
+                        )
+                    return enriched
+
+                enriched_deposits = _enrich_position_entries(
+                    entries=deposit_entries,
+                    state_entries=state_deposits,
+                    side="deposit",
+                )
+                enriched_borrows = _enrich_position_entries(
+                    entries=borrow_entries,
+                    state_entries=state_borrows,
+                    side="borrow",
+                )
+
+                collateral_value = sum(
+                    (
+                        _coerce_decimal(entry.get("token_value_usd")) or Decimal("0")
+                        for entry in enriched_deposits
+                    ),
+                    Decimal("0"),
+                )
+                borrow_value = sum(
+                    (
+                        _coerce_decimal(entry.get("token_value_usd")) or Decimal("0")
+                        for entry in enriched_borrows
+                    ),
+                    Decimal("0"),
+                )
+                total_collateral_value += collateral_value
+                total_borrow_value += borrow_value
+                refreshed_stats = obligation.get("refreshedStats")
+                if not isinstance(refreshed_stats, dict):
+                    refreshed_stats = {}
+                position_type = "borrow-lend"
+                if enriched_deposits and not enriched_borrows:
+                    position_type = "lend"
+                elif enriched_borrows and not enriched_deposits:
+                    position_type = "borrow"
+
+                positions.append(
+                    {
+                        "obligation_address": obligation_address,
+                        "market": market_address,
+                        "market_name": market_name,
+                        "market_description": market_description,
+                        "user": wallet_address,
+                        "position_type": position_type,
+                        "has_debt": bool(enriched_borrows),
+                        "timestamp": loan_data.get("timestamp"),
+                        "solana_slot": loan_data.get("solanaSlot"),
+                        "elevation_group": loan_data.get("elevationGroup"),
+                        "leverage": loan_data.get("leverage"),
+                        "collateral_value_usd": _format_decimal(collateral_value),
+                        "borrow_value_usd": _format_decimal(borrow_value),
+                        "net_value_usd": _format_decimal(collateral_value - borrow_value),
+                        "loan_info": {
+                            "current_ltv": loan_info.get("currentLtv"),
+                            "max_ltv": loan_info.get("maxLtv"),
+                            "liquidation_ltv": loan_info.get("liquidationLtv"),
+                            "close_factor": loan_info.get("closeFactor"),
+                            "collateral": {
+                                "deposit_count": len(enriched_deposits),
+                                "total_value_usd": _format_decimal(collateral_value),
+                                "deposits": enriched_deposits,
+                            },
+                            "debt": {
+                                "borrow_count": len(enriched_borrows),
+                                "total_value_usd": _format_decimal(borrow_value),
+                                "borrows": enriched_borrows,
+                            },
+                        },
+                        "refreshed_stats": {
+                            "borrow_limit": refreshed_stats.get("borrowLimit"),
+                            "borrow_liquidation_limit": refreshed_stats.get("borrowLiquidationLimit"),
+                            "borrow_utilization": refreshed_stats.get("borrowUtilization"),
+                            "net_account_value": refreshed_stats.get("netAccountValue"),
+                        },
+                        "source": "kamino+klend-loans",
+                    }
+                )
+
+        return {
+            "chain": "solana",
+            "network": self.network,
+            "user": wallet_address,
+            "market_count_scanned": len(markets),
+            "markets_with_positions_count": len(markets_with_positions),
+            "markets_with_positions": markets_with_positions,
+            "discovered_obligation_count": discovered_obligation_count,
+            "position_count": len(positions),
+            "positions": positions,
+            "total_collateral_value_usd": _format_decimal(total_collateral_value),
+            "total_borrow_value_usd": _format_decimal(total_borrow_value),
+            "total_net_value_usd": _format_decimal(total_collateral_value - total_borrow_value),
+            "reward_summary": {
+                "reward_count": int(reward_snapshot.get("reward_count") or 0),
+                "avg_base_apy": reward_snapshot.get("avg_base_apy"),
+                "avg_boosted_apy": reward_snapshot.get("avg_boosted_apy"),
+                "avg_max_apy": reward_snapshot.get("avg_max_apy"),
+            },
+            "lookup_errors": lookup_errors,
+            "source": "kamino+klend-loans",
+        }
+
     async def get_state(self) -> SolanaWalletState:
         balance_native = None
         if self.address:
@@ -3790,53 +3299,6 @@ class SolanaWalletBackend(AgentWalletBackend):
         )
         return encode_transaction_base64(bytes(signed_transaction))
 
-    async def _prepare_jupiter_lend_transaction(
-        self,
-        *,
-        transaction_base64: str,
-        action: str,
-        asset: str,
-        amount_raw: str,
-    ) -> dict[str, Any]:
-        if not self.signer:
-            raise WalletBackendError("Solana signer is not configured.")
-        try:
-            from solders.transaction import VersionedTransaction
-        except ImportError as exc:
-            raise WalletBackendError(
-                "solana and solders packages are required for Jupiter Earn transaction signing."
-            ) from exc
-        unsigned_transaction = VersionedTransaction.from_bytes(base64.b64decode(transaction_base64))
-        owner = await self.get_address()
-        verification = verify_provider_lend_transaction(
-            unsigned_transaction.message,
-            wallet_address=str(owner),
-            asset_mint=asset,
-            action=f"Jupiter Earn {action}",
-        )
-        signed_transaction_base64 = await self._sign_versioned_provider_transaction(
-            transaction_base64=transaction_base64,
-            wallet_signer_index=int(verification.get("wallet_signer_index") or 0),
-        )
-        return {
-            "chain": "solana",
-            "network": self.network,
-            "mode": "prepare",
-            "asset_type": f"jupiter-earn-{action}",
-            "owner": owner,
-            "asset": asset,
-            "amount_raw": amount_raw,
-            "transaction_base64": signed_transaction_base64,
-            "transaction_encoding": "base64",
-            "transaction_format": "versioned",
-            "signed": True,
-            "broadcasted": False,
-            "confirmed": False,
-            "verification": verification,
-            "sign_only": self.sign_only,
-            "source": "jupiter-lend",
-        }
-
     async def _execute_prepared_provider_transaction(
         self,
         prepared: dict[str, Any],
@@ -3883,12 +3345,6 @@ class SolanaWalletBackend(AgentWalletBackend):
             "kamino_safety": prepared.get("kamino_safety"),
         }
 
-    async def _execute_prepared_jupiter_lend_transaction(self, prepared: dict[str, Any]) -> dict[str, Any]:
-        return await self._execute_prepared_provider_transaction(
-            prepared,
-            source="jupiter-lend",
-        )
-
     def _find_kamino_reserve_entry(
         self,
         *,
@@ -4529,143 +3985,6 @@ class SolanaWalletBackend(AgentWalletBackend):
         result["build_response"] = prepared.get("build_response")
         return result
 
-    async def preview_jupiter_earn_deposit(
-        self,
-        asset: str,
-        amount_raw: str,
-    ) -> dict[str, Any]:
-        self._require_mainnet_jupiter("Jupiter Earn")
-        owner = await self.get_address()
-        if not owner:
-            raise WalletBackendError(
-                "No Solana wallet address configured. Set SOLANA_AGENT_PUBLIC_KEY or a signer."
-            )
-        amount_raw = _require_positive_integer_string(amount_raw, field_name="amount_raw")
-        asset = validate_solana_mint(asset)
-        tokens = await self.get_jupiter_earn_tokens()
-        token_entry = next(
-            (
-                item
-                for item in tokens["tokens"]
-                if isinstance(item, dict)
-                and str(item.get("asset") or item.get("mint") or "").strip() == asset
-            ),
-            None,
-        )
-        if token_entry is None:
-            raise WalletBackendError("Requested asset is not currently available in Jupiter Earn.")
-        return {
-            "chain": "solana",
-            "network": self.network,
-            "mode": "preview",
-            "asset_type": "jupiter-earn-deposit",
-            "owner": owner,
-            "asset": asset,
-            "amount_raw": amount_raw,
-            "token": token_entry,
-            "sign_only": self.sign_only,
-            "can_send": self.get_capabilities().can_send_transaction,
-            "source": "jupiter-lend",
-        }
-
-    async def prepare_jupiter_earn_deposit(
-        self,
-        asset: str,
-        amount_raw: str,
-    ) -> dict[str, Any]:
-        preview = await self.preview_jupiter_earn_deposit(asset=asset, amount_raw=amount_raw)
-        owner = str(preview["owner"])
-        build = await jupiter.build_earn_deposit_transaction(
-            asset=str(preview["asset"]),
-            user_address=owner,
-            amount_raw=str(preview["amount_raw"]),
-        )
-        prepared = await self._prepare_jupiter_lend_transaction(
-            transaction_base64=str(build["transaction"]),
-            action="deposit",
-            asset=str(preview["asset"]),
-            amount_raw=str(preview["amount_raw"]),
-        )
-        prepared["build_response"] = build
-        return prepared
-
-    async def execute_jupiter_earn_deposit(
-        self,
-        asset: str,
-        amount_raw: str,
-    ) -> dict[str, Any]:
-        prepared = await self.prepare_jupiter_earn_deposit(asset=asset, amount_raw=amount_raw)
-        result = await self._execute_prepared_jupiter_lend_transaction(prepared)
-        result["build_response"] = prepared.get("build_response")
-        return result
-
-    async def preview_jupiter_earn_withdraw(
-        self,
-        asset: str,
-        amount_raw: str,
-    ) -> dict[str, Any]:
-        self._require_mainnet_jupiter("Jupiter Earn")
-        owner = await self.get_address()
-        if not owner:
-            raise WalletBackendError(
-                "No Solana wallet address configured. Set SOLANA_AGENT_PUBLIC_KEY or a signer."
-            )
-        amount_raw = _require_positive_integer_string(amount_raw, field_name="amount_raw")
-        asset = validate_solana_mint(asset)
-        positions = await self.get_jupiter_earn_positions(users=[owner])
-        matching_positions = [
-            item
-            for item in positions["positions"]
-            if isinstance(item, dict)
-            and str(item.get("asset") or item.get("mint") or "").strip() == asset
-        ]
-        if not matching_positions:
-            raise WalletBackendError("No Jupiter Earn position found for the requested asset.")
-        return {
-            "chain": "solana",
-            "network": self.network,
-            "mode": "preview",
-            "asset_type": "jupiter-earn-withdraw",
-            "owner": owner,
-            "asset": asset,
-            "amount_raw": amount_raw,
-            "positions": matching_positions,
-            "sign_only": self.sign_only,
-            "can_send": self.get_capabilities().can_send_transaction,
-            "source": "jupiter-lend",
-        }
-
-    async def prepare_jupiter_earn_withdraw(
-        self,
-        asset: str,
-        amount_raw: str,
-    ) -> dict[str, Any]:
-        preview = await self.preview_jupiter_earn_withdraw(asset=asset, amount_raw=amount_raw)
-        owner = str(preview["owner"])
-        build = await jupiter.build_earn_withdraw_transaction(
-            asset=str(preview["asset"]),
-            user_address=owner,
-            amount_raw=str(preview["amount_raw"]),
-        )
-        prepared = await self._prepare_jupiter_lend_transaction(
-            transaction_base64=str(build["transaction"]),
-            action="withdraw",
-            asset=str(preview["asset"]),
-            amount_raw=str(preview["amount_raw"]),
-        )
-        prepared["build_response"] = build
-        return prepared
-
-    async def execute_jupiter_earn_withdraw(
-        self,
-        asset: str,
-        amount_raw: str,
-    ) -> dict[str, Any]:
-        prepared = await self.prepare_jupiter_earn_withdraw(asset=asset, amount_raw=amount_raw)
-        result = await self._execute_prepared_jupiter_lend_transaction(prepared)
-        result["build_response"] = prepared.get("build_response")
-        return result
-
     async def preview_native_transfer(
         self,
         recipient: str,
@@ -4809,49 +4128,6 @@ class SolanaWalletBackend(AgentWalletBackend):
             "source": "solana-rpc",
         }
 
-    async def request_testnet_airdrop(self, amount_native: float) -> dict[str, Any]:
-        if self.network not in {"devnet", "testnet"}:
-            raise WalletBackendError("Airdrop is only available on Solana devnet or testnet.")
-        if amount_native <= 0:
-            raise WalletBackendError("amount must be greater than zero.")
-
-        address = await self.get_address()
-        if not address:
-            raise WalletBackendError(
-                "No Solana wallet address configured. Set SOLANA_AGENT_PUBLIC_KEY or a signer."
-            )
-
-        lamports = int(round(amount_native * solana_rpc.LAMPORTS_PER_SOL))
-        submitted = await solana_rpc.request_airdrop(
-            address=address,
-            lamports=lamports,
-            rpc_url=self.rpc_urls,
-            commitment=self.commitment,
-        )
-        signature = submitted.get("signature")
-        status = None
-        confirmed = False
-        if isinstance(signature, str) and signature:
-            status = await solana_rpc.wait_for_confirmation(
-                signature=signature,
-                rpc_url=self.rpc_urls,
-            )
-            confirmed = status is not None
-
-        return {
-            "chain": "solana",
-            "network": self.network,
-            "mode": "airdrop",
-            "address": address,
-            "amount_native": amount_native,
-            "amount_lamports": lamports,
-            "signature": signature,
-            "confirmed": confirmed,
-            "confirmation_status": status.get("confirmationStatus") if status else None,
-            "slot": status.get("slot") if status else None,
-            "source": "solana-rpc",
-        }
-
     async def _resolve_mint_decimals(self, mint: str) -> int:
         if mint == NATIVE_SOL_MINT:
             return 9