@agentlayer.tech/wallet 0.1.0

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

@@ -0,0 +1,215 @@
+"""Kamino REST API provider for lending market data and unsigned transaction building."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from agent_wallet.config import settings
+from agent_wallet.exceptions import ProviderError
+from agent_wallet.http_client import get_client
+
+
+def _normalized_api_base() -> str:
+    return settings.kamino_api_base_url.rstrip("/")
+
+
+def _normalize_named_list_response(
+    data: Any,
+    *,
+    key: str,
+    provider_name: str,
+) -> dict[str, Any]:
+    if isinstance(data, list):
+        return {key: data}
+    if isinstance(data, dict):
+        items = data.get(key)
+        if isinstance(items, list):
+            return data
+        fallback = data.get("data")
+        if isinstance(fallback, list):
+            normalized = dict(data)
+            normalized[key] = fallback
+            return normalized
+    raise ProviderError(provider_name, f"Unexpected {key} response from Kamino.")
+
+
+def _normalized_tx_response(data: Any, *, provider_name: str) -> dict[str, Any]:
+    if not isinstance(data, dict) or not isinstance(data.get("transaction"), str):
+        raise ProviderError(provider_name, "Unexpected transaction build response from Kamino.")
+    return data
+
+
+def _env_name(network: str) -> str:
+    normalized = str(network).strip().lower()
+    if normalized == "devnet":
+        return "devnet"
+    return "mainnet-beta"
+
+
+async def fetch_lend_markets() -> dict[str, Any]:
+    """Fetch Kamino lending markets for the configured program id."""
+    client = get_client()
+    response = await client.get(
+        f"{_normalized_api_base()}/v2/kamino-market",
+        params={"programId": settings.kamino_program_id},
+    )
+    if response.status_code != 200:
+        raise ProviderError("kamino", f"HTTP {response.status_code}: {response.text[:300]}")
+    return _normalize_named_list_response(
+        response.json(),
+        key="markets",
+        provider_name="kamino",
+    )
+
+
+async def fetch_lend_market_reserves(
+    *,
+    market: str,
+    network: str,
+) -> dict[str, Any]:
+    """Fetch reserve metrics for one Kamino lending market."""
+    client = get_client()
+    response = await client.get(
+        f"{_normalized_api_base()}/kamino-market/{market}/reserves/metrics",
+        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="reserves",
+        provider_name="kamino",
+    )
+
+
+async def fetch_lend_user_obligations(
+    *,
+    market: str,
+    user: str,
+    network: str,
+) -> dict[str, Any]:
+    """Fetch Kamino obligations for a wallet in a market."""
+    client = get_client()
+    response = await client.get(
+        f"{_normalized_api_base()}/kamino-market/{market}/users/{user}/obligations",
+        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="obligations",
+        provider_name="kamino",
+    )
+
+
+async def fetch_lend_user_rewards(*, user: str) -> dict[str, Any]:
+    """Fetch Kamino rewards summary for a wallet."""
+    client = get_client()
+    response = await client.get(
+        f"{_normalized_api_base()}/klend/users/{user}/rewards",
+    )
+    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 rewards response from Kamino.")
+    rewards = data.get("rewards")
+    if rewards is None:
+        data = dict(data)
+        data["rewards"] = []
+    elif not isinstance(rewards, list):
+        raise ProviderError("kamino", "Unexpected rewards response from Kamino.")
+    return data
+
+
+async def build_lend_deposit_transaction(
+    *,
+    wallet: str,
+    market: str,
+    reserve: str,
+    amount_ui: str,
+) -> dict[str, Any]:
+    """Build an unsigned Kamino deposit transaction."""
+    client = get_client()
+    response = await client.post(
+        f"{_normalized_api_base()}/ktx/klend/deposit",
+        json={
+            "wallet": wallet,
+            "market": market,
+            "reserve": reserve,
+            "amount": amount_ui,
+        },
+    )
+    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_lend_withdraw_transaction(
+    *,
+    wallet: str,
+    market: str,
+    reserve: str,
+    amount_ui: str,
+) -> dict[str, Any]:
+    """Build an unsigned Kamino withdraw transaction."""
+    client = get_client()
+    response = await client.post(
+        f"{_normalized_api_base()}/ktx/klend/withdraw",
+        json={
+            "wallet": wallet,
+            "market": market,
+            "reserve": reserve,
+            "amount": amount_ui,
+        },
+    )
+    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_lend_borrow_transaction(
+    *,
+    wallet: str,
+    market: str,
+    reserve: str,
+    amount_ui: str,
+) -> dict[str, Any]:
+    """Build an unsigned Kamino borrow transaction."""
+    client = get_client()
+    response = await client.post(
+        f"{_normalized_api_base()}/ktx/klend/borrow",
+        json={
+            "wallet": wallet,
+            "market": market,
+            "reserve": reserve,
+            "amount": amount_ui,
+        },
+    )
+    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_lend_repay_transaction(
+    *,
+    wallet: str,
+    market: str,
+    reserve: str,
+    amount_ui: str,
+) -> dict[str, Any]:
+    """Build an unsigned Kamino repay transaction."""
+    client = get_client()
+    response = await client.post(
+        f"{_normalized_api_base()}/ktx/klend/repay",
+        json={
+            "wallet": wallet,
+            "market": market,
+            "reserve": reserve,
+            "amount": amount_ui,
+        },
+    )
+    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/providers/lifi.py

@@ -0,0 +1,277 @@
+"""LI.FI cross-chain quote and status provider."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from agent_wallet.config import settings
+from agent_wallet.exceptions import ProviderError
+from agent_wallet.http_client import get_client
+
+EVM_NATIVE_TOKEN = "0x0000000000000000000000000000000000000000"
+SOLANA_NATIVE_TOKEN = "11111111111111111111111111111111"
+ALWAYS_DENIED_BRIDGES = ("mayan",)
+
+_CHAIN_ALIASES = {
+    "1": "1",
+    "eth": "1",
+    "ethereum": "1",
+    "mainnet": "1",
+    "eth-mainnet": "1",
+    "8453": "8453",
+    "base": "8453",
+    "base-mainnet": "8453",
+    "1151111081099710": "1151111081099710",
+    "sol": "1151111081099710",
+    "solana": "1151111081099710",
+}
+
+_CHAIN_NAMES_BY_ID = {
+    "1": "ethereum",
+    "8453": "base",
+    "1151111081099710": "solana",
+}
+
+OPENCLAW_SUPPORTED_CHAINS = [
+    {"chain": "ethereum", "chain_id": "1", "key": "eth", "name": "Ethereum", "coin": "ETH"},
+    {"chain": "base", "chain_id": "8453", "key": "bas", "name": "Base", "coin": "ETH"},
+    {"chain": "solana", "chain_id": "1151111081099710", "key": "sol", "name": "Solana", "coin": "SOL"},
+]
+_KNOWN_EVM_TOKEN_ADDRESSES = {
+    "1": {
+        "0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48": "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
+        "0xdac17f958d2ee523a2206206994597c13d831ec7": "0xdAC17F958D2ee523a2206206994597C13D831ec7",
+    },
+    "8453": {
+        "0x833589fcd6edb6e08f4c7c32d4f71b54bda02913": "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
+    },
+}
+
+
+def normalize_chain_id(value: str, *, field_name: str) -> str:
+    chain = str(value or "").strip().lower()
+    normalized = _CHAIN_ALIASES.get(chain, chain)
+    if normalized not in _CHAIN_NAMES_BY_ID:
+        raise ProviderError("lifi", f"{field_name} is not supported by OpenClaw LI.FI routing: {value}")
+    return normalized
+
+
+def chain_name_for_id(chain_id: str) -> str:
+    return _CHAIN_NAMES_BY_ID.get(str(chain_id), str(chain_id))
+
+
+def normalize_token_address(token: str, *, chain_id: str) -> str:
+    text = str(token or "").strip()
+    if not text:
+        raise ProviderError("lifi", "token address is required.")
+    alias = text.lower()
+    if chain_id == "1151111081099710" and alias in {"native", "sol", "solana"}:
+        return SOLANA_NATIVE_TOKEN
+    if chain_id in {"1", "8453"} and alias in {"native", "eth", "ethereum"}:
+        return EVM_NATIVE_TOKEN
+    if chain_id in _KNOWN_EVM_TOKEN_ADDRESSES:
+        known = _KNOWN_EVM_TOKEN_ADDRESSES[chain_id].get(alias)
+        if known:
+            return known.lower()
+    if chain_id in {"1", "8453"} and alias.startswith("0x") and len(alias) == 42:
+        return alias
+    return text
+
+
+def format_openclaw_supported_chains(chains: list[dict[str, Any]]) -> list[dict[str, Any]]:
+    """Return OpenClaw's supported LI.FI subset, including Solana if omitted from discovery."""
+    items = [
+        {
+            "chain_id": str(item.get("id") or item.get("chainId") or "").strip(),
+            "key": str(item.get("key") or "").strip() or None,
+            "name": str(item.get("name") or "").strip() or None,
+            "coin": str(item.get("coin") or "").strip() or None,
+            "native_token": item.get("nativeToken"),
+            "raw": item,
+        }
+        for item in chains
+    ]
+    supported_ids = {chain["chain_id"] for chain in OPENCLAW_SUPPORTED_CHAINS}
+    supported_keys = {chain["key"] for chain in OPENCLAW_SUPPORTED_CHAINS}
+    supported_by_id = {
+        item["chain_id"]: item
+        for item in items
+        if item["chain_id"] in supported_ids or str(item.get("key") or "").lower() in supported_keys
+    }
+    for chain in OPENCLAW_SUPPORTED_CHAINS:
+        supported_by_id.setdefault(
+            chain["chain_id"],
+            {
+                "chain_id": chain["chain_id"],
+                "key": chain["key"],
+                "name": chain["name"],
+                "coin": chain["coin"],
+                "native_token": None,
+                "raw": None,
+            },
+        )
+    return [supported_by_id[chain["chain_id"]] for chain in OPENCLAW_SUPPORTED_CHAINS]
+
+
+def _headers() -> dict[str, str]:
+    headers = {
+        "Accept": "application/json",
+    }
+    api_key = settings.lifi_api_key.strip()
+    if api_key:
+        headers["x-lifi-api-key"] = api_key
+    return headers
+
+
+def _base_url() -> str:
+    return settings.lifi_api_base_url.rstrip("/")
+
+
+def _normalize_error(payload: Any) -> str:
+    if isinstance(payload, dict):
+        message = (
+            payload.get("message")
+            or payload.get("error")
+            or payload.get("detail")
+            or payload.get("description")
+        )
+        if message:
+            return str(message)
+        errors = payload.get("errors")
+        if isinstance(errors, list) and errors:
+            return "; ".join(str(item) for item in errors[:3])
+    return "Route not found."
+
+
+def _csv(value: str | list[str] | tuple[str, ...] | None) -> str | None:
+    if value is None:
+        return None
+    if isinstance(value, str):
+        text = value.strip()
+        return text or None
+    if isinstance(value, (list, tuple)):
+        items = [str(item).strip() for item in value if str(item).strip()]
+        return ",".join(items) if items else None
+    return str(value).strip() or None
+
+
+def _merge_bridge_csv(*values: str | list[str] | tuple[str, ...] | None) -> str | None:
+    items: list[str] = []
+    for value in values:
+        text = _csv(value)
+        if not text:
+            continue
+        for item in text.split(","):
+            bridge = item.strip()
+            if bridge and bridge.lower() not in {existing.lower() for existing in items}:
+                items.append(bridge)
+    return ",".join(items) if items else None
+
+
+def _clean_params(params: dict[str, Any]) -> dict[str, Any]:
+    cleaned: dict[str, Any] = {}
+    for key, value in params.items():
+        if value is None:
+            continue
+        if isinstance(value, str) and not value.strip():
+            continue
+        cleaned[key] = value
+    return cleaned
+
+
+async def fetch_supported_chains() -> list[dict[str, Any]]:
+    client = get_client()
+    response = await client.get(
+        f"{_base_url()}/chains",
+        headers=_headers(),
+    )
+    payload = response.json()
+    if response.status_code != 200:
+        raise ProviderError("lifi", f"HTTP {response.status_code}: {_normalize_error(payload)}")
+    if isinstance(payload, dict) and isinstance(payload.get("chains"), list):
+        return [item for item in payload["chains"] if isinstance(item, dict)]
+    if isinstance(payload, list):
+        return [item for item in payload if isinstance(item, dict)]
+    raise ProviderError("lifi", "Unexpected chains response from LI.FI.")
+
+
+async def fetch_quote(
+    *,
+    from_chain: str,
+    to_chain: str,
+    from_token: str,
+    to_token: str,
+    amount_in_raw: str,
+    from_address: str,
+    to_address: str,
+    slippage: float | int | None = None,
+    integrator: str | None = None,
+    allow_bridges: str | list[str] | None = None,
+    deny_bridges: str | list[str] | None = None,
+    prefer_bridges: str | list[str] | None = None,
+) -> dict[str, Any]:
+    from_chain_id = normalize_chain_id(from_chain, field_name="from_chain")
+    to_chain_id = normalize_chain_id(to_chain, field_name="to_chain")
+    default_deny_bridges = settings.lifi_default_deny_bridges.strip()
+    effective_deny_bridges = _merge_bridge_csv(
+        default_deny_bridges,
+        deny_bridges,
+        ALWAYS_DENIED_BRIDGES,
+    )
+    params = _clean_params(
+        {
+            "fromChain": from_chain_id,
+            "toChain": to_chain_id,
+            "fromToken": normalize_token_address(from_token, chain_id=from_chain_id),
+            "toToken": normalize_token_address(to_token, chain_id=to_chain_id),
+            "fromAmount": str(amount_in_raw).strip(),
+            "fromAddress": str(from_address).strip(),
+            "toAddress": str(to_address).strip(),
+            "slippage": slippage,
+            "integrator": (integrator or settings.lifi_integrator).strip(),
+            "allowBridges": _csv(allow_bridges),
+            "denyBridges": effective_deny_bridges,
+            "preferBridges": _csv(prefer_bridges),
+        }
+    )
+    client = get_client()
+    response = await client.get(
+        f"{_base_url()}/quote",
+        params=params,
+        headers=_headers(),
+    )
+    payload = response.json()
+    if response.status_code != 200:
+        raise ProviderError("lifi", f"HTTP {response.status_code}: {_normalize_error(payload)}")
+    if not isinstance(payload, dict):
+        raise ProviderError("lifi", "Unexpected quote response from LI.FI.")
+    return payload
+
+
+async def fetch_transfer_status(
+    *,
+    tx_hash: str,
+    bridge: str | None = None,
+    from_chain: str | None = None,
+    to_chain: str | None = None,
+) -> dict[str, Any]:
+    params = _clean_params(
+        {
+            "txHash": str(tx_hash).strip(),
+            "bridge": str(bridge).strip() if isinstance(bridge, str) else None,
+            "fromChain": normalize_chain_id(from_chain, field_name="from_chain") if from_chain else None,
+            "toChain": normalize_chain_id(to_chain, field_name="to_chain") if to_chain else None,
+        }
+    )
+    client = get_client()
+    response = await client.get(
+        f"{_base_url()}/status",
+        params=params,
+        headers=_headers(),
+    )
+    payload = response.json()
+    if response.status_code != 200:
+        raise ProviderError("lifi", f"HTTP {response.status_code}: {_normalize_error(payload)}")
+    if not isinstance(payload, dict):
+        raise ProviderError("lifi", "Unexpected status response from LI.FI.")
+    return payload