@agentlayer.tech/wallet 0.1.66 → 0.1.67

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

@@ -2,6 +2,8 @@
 
 from __future__ import annotations
 
+import json
+import time
 from typing import Any
 
 from agent_wallet.config import normalize_solana_network, settings
@@ -9,6 +11,41 @@ from agent_wallet.exceptions import ProviderError
 from agent_wallet.http_client import get_client
 
 KAMINO_BUILD_TIMEOUT_SECONDS = 20.0
+# Discovery data only (market/vault catalogs and rate metrics) — never
+# user-specific data such as obligations, positions, rewards, or portfolios.
+# Catalogs change when Kamino ships a market/vault (days); rate metrics drift
+# slower than the API's own aggregation window over these TTLs. The cache is
+# long-lived only inside the resident read worker; cold CLI runs start empty.
+MARKETS_CACHE_TTL_SECONDS = 600.0
+RESERVES_CACHE_TTL_SECONDS = 180.0
+EARN_VAULTS_CACHE_TTL_SECONDS = 600.0
+EARN_VAULT_METRICS_CACHE_TTL_SECONDS = 180.0
+_DISCOVERY_CACHE_MAX_ENTRIES = 128
+_discovery_cache: dict[str, tuple[float, str]] = {}
+
+
+def _discovery_cache_get(cache_key: str) -> Any | None:
+    entry = _discovery_cache.get(cache_key)
+    if entry is None:
+        return None
+    expires_at, payload_text = entry
+    if expires_at <= time.monotonic():
+        _discovery_cache.pop(cache_key, None)
+        return None
+    return json.loads(payload_text)
+
+
+def _discovery_cache_set(cache_key: str, payload: Any, ttl_seconds: float) -> None:
+    try:
+        payload_text = json.dumps(payload)
+    except (TypeError, ValueError):
+        return
+    if len(_discovery_cache) >= _DISCOVERY_CACHE_MAX_ENTRIES:
+        for stale_key in sorted(_discovery_cache, key=lambda key: _discovery_cache[key][0])[
+            : len(_discovery_cache) - _DISCOVERY_CACHE_MAX_ENTRIES + 1
+        ]:
+            _discovery_cache.pop(stale_key, None)
+    _discovery_cache[cache_key] = (time.monotonic() + ttl_seconds, payload_text)
 
 
 def _normalized_api_base() -> str:
@@ -48,6 +85,10 @@ def _env_name(network: str) -> str:
 
 async def fetch_lend_markets() -> dict[str, Any]:
     """Fetch Kamino lending markets for the configured program id."""
+    cache_key = f"markets:{settings.kamino_program_id}"
+    cached = _discovery_cache_get(cache_key)
+    if cached is not None:
+        return cached
     client = get_client()
     response = await client.get(
         f"{_normalized_api_base()}/v2/kamino-market",
@@ -55,11 +96,85 @@ async def fetch_lend_markets() -> dict[str, Any]:
     )
     if response.status_code != 200:
         raise ProviderError("kamino", f"HTTP {response.status_code}: {response.text[:300]}")
-    return _normalize_named_list_response(
+    result = _normalize_named_list_response(
         response.json(),
         key="markets",
         provider_name="kamino",
     )
+    _discovery_cache_set(cache_key, result, MARKETS_CACHE_TTL_SECONDS)
+    return result
+
+
+async def fetch_portfolio(*, user: str) -> dict[str, Any]:
+    """Fetch the unified Kamino product portfolio for one wallet."""
+    client = get_client()
+    response = await client.get(f"{_normalized_api_base()}/portfolio/{user}")
+    if response.status_code != 200:
+        raise ProviderError("kamino", f"HTTP {response.status_code}: {response.text[:300]}")
+    data = response.json()
+    if not isinstance(data, dict):
+        raise ProviderError("kamino", "Unexpected portfolio response from Kamino.")
+    return data
+
+
+async def fetch_earn_vaults() -> dict[str, Any]:
+    """Fetch the list of Kamino Earn vaults."""
+    cache_key = "earn_vaults"
+    cached = _discovery_cache_get(cache_key)
+    if cached is not None:
+        return cached
+    client = get_client()
+    response = await client.get(f"{_normalized_api_base()}/kvaults/vaults")
+    if response.status_code != 200:
+        raise ProviderError("kamino", f"HTTP {response.status_code}: {response.text[:300]}")
+    result = _normalize_named_list_response(
+        response.json(),
+        key="vaults",
+        provider_name="kamino",
+    )
+    _discovery_cache_set(cache_key, result, EARN_VAULTS_CACHE_TTL_SECONDS)
+    return result
+
+
+async def fetch_earn_vault_metrics(*, vault: str, network: str) -> dict[str, Any]:
+    """Fetch APY/TVL metrics for one Kamino Earn vault."""
+    env = _env_name(network)
+    cache_key = f"earn_vault_metrics:{vault}:{env}"
+    cached = _discovery_cache_get(cache_key)
+    if cached is not None:
+        return cached
+    client = get_client()
+    response = await client.get(
+        f"{_normalized_api_base()}/kvaults/{vault}/metrics",
+        params={"env": env},
+    )
+    if response.status_code != 200:
+        raise ProviderError("kamino", f"HTTP {response.status_code}: {response.text[:300]}")
+    data = response.json()
+    if not isinstance(data, dict):
+        raise ProviderError("kamino", "Unexpected vault metrics response from Kamino.")
+    _discovery_cache_set(cache_key, data, EARN_VAULT_METRICS_CACHE_TTL_SECONDS)
+    return data
+
+
+async def fetch_earn_user_positions(
+    *,
+    user: str,
+    network: str,
+) -> dict[str, Any]:
+    """Fetch all Kamino Earn vault positions for a wallet."""
+    client = get_client()
+    response = await client.get(
+        f"{_normalized_api_base()}/kvaults/users/{user}/positions",
+        params={"env": _env_name(network)},
+    )
+    if response.status_code != 200:
+        raise ProviderError("kamino", f"HTTP {response.status_code}: {response.text[:300]}")
+    return _normalize_named_list_response(
+        response.json(),
+        key="positions",
+        provider_name="kamino",
+    )
 
 
 async def fetch_lend_market_reserves(
@@ -68,18 +183,25 @@ async def fetch_lend_market_reserves(
     network: str,
 ) -> dict[str, Any]:
     """Fetch reserve metrics for one Kamino lending market."""
+    env = _env_name(network)
+    cache_key = f"reserves:{market}:{env}"
+    cached = _discovery_cache_get(cache_key)
+    if cached is not None:
+        return cached
     client = get_client()
     response = await client.get(
         f"{_normalized_api_base()}/kamino-market/{market}/reserves/metrics",
-        params={"env": _env_name(network)},
+        params={"env": env},
     )
     if response.status_code != 200:
         raise ProviderError("kamino", f"HTTP {response.status_code}: {response.text[:300]}")
-    return _normalize_named_list_response(
+    result = _normalize_named_list_response(
         response.json(),
         key="reserves",
         provider_name="kamino",
     )
+    _discovery_cache_set(cache_key, result, RESERVES_CACHE_TTL_SECONDS)
+    return result
 
 
 async def fetch_lend_user_obligations(
@@ -236,3 +358,47 @@ async def build_lend_repay_transaction(
     if response.status_code != 200:
         raise ProviderError("kamino", f"HTTP {response.status_code}: {response.text[:300]}")
     return _normalized_tx_response(response.json(), provider_name="kamino")
+
+
+async def build_earn_deposit_transaction(
+    *,
+    wallet: str,
+    kvault: str,
+    amount_ui: str,
+) -> dict[str, Any]:
+    """Build an unsigned Kamino Earn deposit transaction."""
+    client = get_client()
+    response = await client.post(
+        f"{_normalized_api_base()}/ktx/kvault/deposit",
+        json={
+            "wallet": wallet,
+            "kvault": kvault,
+            "amount": amount_ui,
+        },
+        timeout=KAMINO_BUILD_TIMEOUT_SECONDS,
+    )
+    if response.status_code != 200:
+        raise ProviderError("kamino", f"HTTP {response.status_code}: {response.text[:300]}")
+    return _normalized_tx_response(response.json(), provider_name="kamino")
+
+
+async def build_earn_withdraw_transaction(
+    *,
+    wallet: str,
+    kvault: str,
+    amount_ui: str,
+) -> dict[str, Any]:
+    """Build an unsigned Kamino Earn withdraw transaction."""
+    client = get_client()
+    response = await client.post(
+        f"{_normalized_api_base()}/ktx/kvault/withdraw",
+        json={
+            "wallet": wallet,
+            "kvault": kvault,
+            "amount": amount_ui,
+        },
+        timeout=KAMINO_BUILD_TIMEOUT_SECONDS,
+    )
+    if response.status_code != 200:
+        raise ProviderError("kamino", f"HTTP {response.status_code}: {response.text[:300]}")
+    return _normalized_tx_response(response.json(), provider_name="kamino")

package/agent-wallet/agent_wallet/transaction_policy.py

@@ -18,6 +18,7 @@ JUPITER_V6_PROGRAM_ID = "JUP6LkbZbjS1jKKwapdHNy74zcZ3tLUZoi5Nt7NQYjN"
 JUPITER_ULTRA_EXACT_OUT_PROGRAM_ID = "j1o2qRpjcyUwEvwtcfhEQefh773ZgjxcVRry7LDqg5X"
 JUPITER_DCA_PROGRAM_ID = "DCA265Vj8a7wYymQG8LqM3m7A4QeV9hiC7VYh4S6Jsa"
 KAMINO_LEND_PROGRAM_ID = "KLend2g3cP87fffoy8q1mQqGKjrxjC8boSyAYavgmjD"
+KAMINO_EARN_PROGRAM_ID = "KvauGMspG5k6rtzrqqn7WNn3oZdyKqLKwK2XWQ8FLjd"
 NATIVE_SOL_MINT = "So11111111111111111111111111111111111111112"
 DEFAULT_NATIVE_SOL_EXTRA_SPEND_ALLOWANCE_LAMPORTS = 10_000_000
 
@@ -45,6 +46,7 @@ FORBIDDEN_PROGRAMS = {
 }
 KAMINO_ALLOWED_PROGRAMS = CORE_PROGRAM_IDS | {
     KAMINO_LEND_PROGRAM_ID,
+    KAMINO_EARN_PROGRAM_ID,
 }
 
 
@@ -513,6 +515,64 @@ def verify_provider_kamino_lend_transaction(
     }
 
 
+def verify_provider_kamino_earn_transaction(
+    message: Any,
+    *,
+    wallet_address: str,
+    vault_address: str,
+    action: str,
+    vault_token_mint: str | None = None,
+    loaded_addresses: list[str] | None = None,
+) -> dict[str, Any]:
+    binding = _assert_basic_wallet_binding(
+        message,
+        wallet_address=wallet_address,
+        loaded_addresses=loaded_addresses,
+    )
+    keys = binding["account_keys"]
+    if vault_address not in keys:
+        raise WalletBackendError(
+            f"{action} transaction does not reference the expected Kamino Earn vault."
+        )
+    if vault_token_mint and vault_token_mint not in keys:
+        raise WalletBackendError(
+            f"{action} transaction does not reference the expected Kamino Earn vault token mint."
+        )
+    program_ids = _program_ids(message, loaded_addresses)
+    unknown_program_ids = _assert_program_allowlist(
+        program_ids,
+        allowed_programs=KAMINO_ALLOWED_PROGRAMS,
+        label=action,
+        reject_unknown=False,
+    )
+    recognized_kamino_program_ids = [
+        pid for pid in program_ids if pid == KAMINO_EARN_PROGRAM_ID
+    ]
+    if not recognized_kamino_program_ids:
+        raise WalletBackendError(
+            f"{action} transaction does not include the expected Kamino Earn program."
+        )
+    return {
+        "wallet_address": wallet_address,
+        "fee_payer": binding["fee_payer"],
+        "required_signer_keys": binding["required_signer_keys"],
+        "required_signature_count": binding["required_signature_count"],
+        "wallet_signer_index": binding["wallet_signer_index"],
+        "sponsored_fee_payer": binding["sponsored_fee_payer"],
+        "program_ids": program_ids,
+        "unknown_program_ids": unknown_program_ids,
+        "recognized_kamino_program_ids": recognized_kamino_program_ids,
+        "has_recognized_kamino_program": True,
+        "non_core_program_ids": [pid for pid in program_ids if pid not in CORE_PROGRAM_IDS],
+        "account_key_count": len(keys),
+        "instruction_count": len(_compiled_instructions(message)),
+        "vault_address": vault_address,
+        "vault_token_mint": vault_token_mint,
+        "action": action,
+        "verified": True,
+    }
+
+
 def verify_provider_flash_transaction(
     message: Any,
     *,

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

@@ -549,6 +549,24 @@ class AgentWalletBackend(ABC):
     async def get_kamino_lend_markets(self) -> dict[str, Any]:
         raise WalletBackendError(f"{self.name} does not support Kamino market lookup.")
 
+    async def get_kamino_portfolio(self, user: str | None = None) -> dict[str, Any]:
+        raise WalletBackendError(f"{self.name} does not support Kamino portfolio lookup.")
+
+    async def get_kamino_vaults(
+        self,
+        vault_address: str | None = None,
+        token_mint: str | None = None,
+        include_metrics: bool = False,
+        limit: int | None = None,
+    ) -> dict[str, Any]:
+        raise WalletBackendError(f"{self.name} does not support Kamino vault lookup.")
+
+    async def get_kamino_earn_positions(self, user: str | None = None) -> dict[str, Any]:
+        raise WalletBackendError(f"{self.name} does not support Kamino Earn position lookup.")
+
+    async def get_kamino_liquidity_positions(self, user: str | None = None) -> dict[str, Any]:
+        raise WalletBackendError(f"{self.name} does not support Kamino liquidity position lookup.")
+
     async def get_kamino_lend_market_reserves(self, market: str) -> dict[str, Any]:
         raise WalletBackendError(f"{self.name} does not support Kamino reserve lookup.")
 
@@ -791,6 +809,112 @@ class AgentWalletBackend(ABC):
     ) -> dict[str, Any]:
         raise WalletBackendError(f"{self.name} does not support Kamino repays.")
 
+    async def preview_kamino_earn_deposit(
+        self,
+        kvault: str,
+        amount_ui: str,
+    ) -> dict[str, Any]:
+        raise WalletBackendError(f"{self.name} does not support Kamino Earn deposit previews.")
+
+    def _build_kamino_earn_intent_preview(
+        self,
+        base_preview: dict[str, Any],
+        *,
+        valid_for_seconds: int,
+    ) -> dict[str, Any]:
+        if valid_for_seconds <= 0 or valid_for_seconds > 300:
+            raise WalletBackendError("valid_for_seconds must be between 1 and 300.")
+        try:
+            can_send = bool(self.get_capabilities().can_send_transaction)
+        except Exception:
+            can_send = bool(base_preview.get("can_send"))
+        return {
+            "chain": "solana",
+            "network": getattr(self, "network", "mainnet"),
+            "mode": "intent_preview",
+            "asset_type": "kamino-earn-intent",
+            "kamino_operation": base_preview["asset_type"],
+            "owner": base_preview["owner"],
+            "kvault": base_preview["kvault"],
+            "amount_ui": base_preview["amount_ui"],
+            "vault_info": base_preview.get("vault_info"),
+            "position_info": base_preview.get("position_info"),
+            "recipient_policy": "owner-only",
+            "spend_policy": "exact-amount",
+            "valid_for_seconds": valid_for_seconds,
+            "valid_until_epoch_seconds": int(time.time()) + valid_for_seconds,
+            "intent_note": (
+                "This is an intent approval preview. Execute re-derives the Kamino "
+                "Earn transaction and only signs/sends if it remains within these approved parameters."
+            ),
+            "can_send": can_send,
+            "sign_only": bool(getattr(self, "sign_only", False)),
+            "source": "kamino-intent",
+        }
+
+    async def preview_kamino_earn_deposit_intent(
+        self,
+        kvault: str,
+        amount_ui: str,
+        valid_for_seconds: int = 120,
+    ) -> dict[str, Any]:
+        base = await self.preview_kamino_earn_deposit(
+            kvault=kvault,
+            amount_ui=amount_ui,
+        )
+        return self._build_kamino_earn_intent_preview(base, valid_for_seconds=valid_for_seconds)
+
+    async def prepare_kamino_earn_deposit(
+        self,
+        kvault: str,
+        amount_ui: str,
+        approved_preview: dict[str, Any] | None = None,
+    ) -> dict[str, Any]:
+        raise WalletBackendError(f"{self.name} does not support Kamino Earn deposit preparation.")
+
+    async def execute_kamino_earn_deposit(
+        self,
+        kvault: str,
+        amount_ui: str,
+        approved_preview: dict[str, Any] | None = None,
+    ) -> dict[str, Any]:
+        raise WalletBackendError(f"{self.name} does not support Kamino Earn deposits.")
+
+    async def preview_kamino_earn_withdraw(
+        self,
+        kvault: str,
+        amount_ui: str,
+    ) -> dict[str, Any]:
+        raise WalletBackendError(f"{self.name} does not support Kamino Earn withdraw previews.")
+
+    async def preview_kamino_earn_withdraw_intent(
+        self,
+        kvault: str,
+        amount_ui: str,
+        valid_for_seconds: int = 120,
+    ) -> dict[str, Any]:
+        base = await self.preview_kamino_earn_withdraw(
+            kvault=kvault,
+            amount_ui=amount_ui,
+        )
+        return self._build_kamino_earn_intent_preview(base, valid_for_seconds=valid_for_seconds)
+
+    async def prepare_kamino_earn_withdraw(
+        self,
+        kvault: str,
+        amount_ui: str,
+        approved_preview: dict[str, Any] | None = None,
+    ) -> dict[str, Any]:
+        raise WalletBackendError(f"{self.name} does not support Kamino Earn withdraw preparation.")
+
+    async def execute_kamino_earn_withdraw(
+        self,
+        kvault: str,
+        amount_ui: str,
+        approved_preview: dict[str, Any] | None = None,
+    ) -> dict[str, Any]:
+        raise WalletBackendError(f"{self.name} does not support Kamino Earn withdraws.")
+
     async def preview_close_empty_token_accounts(
         self,
         limit: int = 8,