@agentlayer.tech/wallet 0.1.44 → 0.1.48

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

@@ -119,6 +119,22 @@ def _normalize_lido_withdrawal_operation(value: str) -> str:
     return operation
 
 
+def _normalize_morpho_vault_operation(value: str) -> str:
+    operation = str(value or "").strip().lower()
+    if operation not in {"supply", "withdraw"}:
+        raise WalletBackendError("Morpho vault operation must be one of: supply, withdraw.")
+    return operation
+
+
+def _normalize_morpho_market_operation(value: str) -> str:
+    operation = str(value or "").strip().lower()
+    if operation not in {"supply_collateral", "borrow", "repay", "withdraw_collateral"}:
+        raise WalletBackendError(
+            "Morpho market operation must be one of: supply_collateral, borrow, repay, withdraw_collateral."
+        )
+    return operation
+
+
 def _normalize_aave_payload(
     *,
     chain: str,
@@ -296,6 +312,88 @@ def _normalize_lido_withdrawal_payload(
     }
 
 
+def _normalize_morpho_payload(
+    *,
+    chain: str,
+    network: str,
+    wallet_id: str,
+    address: str,
+    operation: str,
+    token_address: str,
+    amount_raw: str | None,
+    native_amount_raw: str | None,
+    data: dict[str, Any],
+    sign_only: bool,
+) -> dict[str, Any]:
+    result = dict(data.get("result") or {})
+    request = dict(data.get("operationRequest") or {})
+    requirements = dict(data.get("requirements") or {})
+    resolved_amount = (
+        str(request.get("amount"))
+        if request.get("amount") is not None
+        else (str(amount_raw) if amount_raw is not None else None)
+    )
+    resolved_native_amount = (
+        str(request.get("nativeAmount"))
+        if request.get("nativeAmount") is not None
+        else (str(native_amount_raw) if native_amount_raw is not None else None)
+    )
+    target = dict(data.get("target") or {})
+    surface = str(data.get("surface") or target.get("type") or "").strip().lower() or None
+    asset_type = "evm-morpho-vault" if surface == "vault" else "evm-morpho-market"
+    return {
+        "chain": chain,
+        "network": network,
+        "asset_type": asset_type,
+        "asset": "ERC20",
+        "wallet": wallet_id,
+        "from_address": str(data.get("address") or address),
+        "protocol": str(data.get("protocol") or "morpho"),
+        "surface": surface,
+        "operation": str(data.get("operation") or operation),
+        "target": target,
+        "token_address": str(request.get("token") or token_address),
+        "amount_raw": resolved_amount,
+        "native_amount_raw": resolved_native_amount,
+        "amount_ui": str(data.get("amountFormatted")) if data.get("amountFormatted") is not None else None,
+        "native_amount_ui": (
+            str(data.get("nativeAmountFormatted"))
+            if data.get("nativeAmountFormatted") is not None
+            else None
+        ),
+        "estimated_fee_wei": str(data.get("estimatedFeeWei")) if data.get("estimatedFeeWei") is not None else None,
+        "estimated_operation_fee_wei": (
+            str(data.get("estimatedOperationFeeWei"))
+            if data.get("estimatedOperationFeeWei") is not None
+            else None
+        ),
+        "estimated_requirements_fee_wei": (
+            str(data.get("estimatedRequirementsFeeWei"))
+            if data.get("estimatedRequirementsFeeWei") is not None
+            else None
+        ),
+        "fee_estimate_available": bool(data.get("feeEstimateAvailable", True)),
+        "fee_estimate_error": data.get("feeEstimateError"),
+        "execution_supported": bool(data.get("executionSupported", True)) and not sign_only,
+        "quote_fingerprint": str(data.get("quoteFingerprint") or "").strip() or None,
+        "requirements": {
+            "required": bool(requirements.get("required")),
+            "requirement_count": int(requirements.get("requirementCount") or 0),
+            "approval_required": bool(requirements.get("approvalRequired")),
+            "authorization_required": bool(requirements.get("authorizationRequired")),
+            "sequence": list(requirements.get("sequence") or []),
+        },
+        "token_metadata": _normalize_token_metadata(
+            data.get("tokenMetadata"),
+            str(request.get("token") or token_address),
+        ),
+        "hash": result.get("hash"),
+        "result": result,
+        "chain_id": int(data.get("chainId") or 0),
+        "source": "wdk-evm-wallet",
+    }
+
+
 def _normalize_lifi_cross_chain_payload(
     *,
     chain: str,
@@ -921,6 +1019,122 @@ class WdkEvmLocalWalletBackend(AgentWalletBackend):
             "source": "wdk-evm-wallet",
         }
 
+    async def get_evm_morpho_vaults(
+        self,
+        *,
+        vault_address: str | None = None,
+        limit: int | None = None,
+        listed_only: bool = True,
+        asset_address: str | None = None,
+        order_by: str | None = None,
+        order_direction: str | None = None,
+    ) -> dict[str, Any]:
+        payload: dict[str, Any] = {
+            "network": self.network,
+            "listedOnly": bool(listed_only),
+        }
+        if isinstance(vault_address, str) and vault_address.strip():
+            payload["vaultAddress"] = vault_address.strip()
+        if limit is not None:
+            payload["limit"] = int(limit)
+        if isinstance(asset_address, str) and asset_address.strip():
+            payload["assetAddress"] = asset_address.strip()
+        if isinstance(order_by, str) and order_by.strip():
+            payload["orderBy"] = order_by.strip()
+        if isinstance(order_direction, str) and order_direction.strip():
+            payload["orderDirection"] = order_direction.strip()
+        data = await self.client.post("/v1/evm/morpho/vaults/get", payload)
+        return {
+            "chain": self.chain,
+            "network": self.network,
+            "protocol": str(data.get("protocol") or "morpho"),
+            "chain_id": int(data.get("chainId") or 0),
+            "listed_only": bool(data.get("listedOnly", listed_only)),
+            "requested_limit": int(data.get("requestedLimit") or 0),
+            "order_by": data.get("orderBy"),
+            "order_direction": data.get("orderDirection"),
+            "asset_address_filter": data.get("assetAddressFilter"),
+            "found": bool(data.get("found")) if "found" in data else None,
+            "vault_count": int(data.get("vaultCount") or 0),
+            "vault": dict(data.get("vault") or {}) if isinstance(data.get("vault"), dict) else None,
+            "vaults": list(data.get("vaults") or []),
+            "source": "wdk-evm-wallet",
+        }
+
+    async def get_evm_morpho_markets(
+        self,
+        *,
+        market_id: str | None = None,
+        limit: int | None = None,
+        listed_only: bool = True,
+        search: str | None = None,
+        collateral_asset_address: str | None = None,
+        loan_asset_address: str | None = None,
+        order_by: str | None = None,
+        order_direction: str | None = None,
+    ) -> dict[str, Any]:
+        payload: dict[str, Any] = {
+            "network": self.network,
+            "listedOnly": bool(listed_only),
+        }
+        if isinstance(market_id, str) and market_id.strip():
+            payload["marketId"] = market_id.strip()
+        if limit is not None:
+            payload["limit"] = int(limit)
+        if isinstance(search, str) and search.strip():
+            payload["search"] = search.strip()
+        if isinstance(collateral_asset_address, str) and collateral_asset_address.strip():
+            payload["collateralAssetAddress"] = collateral_asset_address.strip()
+        if isinstance(loan_asset_address, str) and loan_asset_address.strip():
+            payload["loanAssetAddress"] = loan_asset_address.strip()
+        if isinstance(order_by, str) and order_by.strip():
+            payload["orderBy"] = order_by.strip()
+        if isinstance(order_direction, str) and order_direction.strip():
+            payload["orderDirection"] = order_direction.strip()
+        data = await self.client.post("/v1/evm/morpho/markets/get", payload)
+        return {
+            "chain": self.chain,
+            "network": self.network,
+            "protocol": str(data.get("protocol") or "morpho"),
+            "chain_id": int(data.get("chainId") or 0),
+            "listed_only": bool(data.get("listedOnly", listed_only)),
+            "requested_limit": int(data.get("requestedLimit") or 0),
+            "order_by": data.get("orderBy"),
+            "order_direction": data.get("orderDirection"),
+            "search": data.get("search"),
+            "collateral_asset_filter": data.get("collateralAssetFilter"),
+            "loan_asset_filter": data.get("loanAssetFilter"),
+            "found": bool(data.get("found")) if "found" in data else None,
+            "market_count": int(data.get("marketCount") or 0),
+            "market": dict(data.get("market") or {}) if isinstance(data.get("market"), dict) else None,
+            "markets": list(data.get("markets") or []),
+            "source": "wdk-evm-wallet",
+        }
+
+    async def get_evm_morpho_positions(self) -> dict[str, Any]:
+        resolved_address = await self.get_address()
+        data = await self.client.post(
+            "/v1/evm/morpho/positions/get",
+            {
+                "walletId": self.wallet_id,
+                "address": resolved_address,
+                "accountIndex": self.account_index,
+                "network": self.network,
+            },
+        )
+        return {
+            "chain": self.chain,
+            "network": self.network,
+            "address": str(data.get("address") or resolved_address or ""),
+            "protocol": str(data.get("protocol") or "morpho"),
+            "chain_id": int(data.get("chainId") or 0),
+            "market_position_count": int(data.get("marketPositionCount") or 0),
+            "vault_position_count": int(data.get("vaultPositionCount") or 0),
+            "market_positions": list(data.get("marketPositions") or []),
+            "vault_positions": list(data.get("vaultPositions") or []),
+            "source": "wdk-evm-wallet",
+        }
+
     async def preview_evm_aave_operation(
         self,
         *,
@@ -1140,6 +1354,196 @@ class WdkEvmLocalWalletBackend(AgentWalletBackend):
             "confirmed": False,
         }
 
+    async def preview_evm_morpho_vault_operation(
+        self,
+        *,
+        operation: str,
+        token_address: str,
+        vault_address: str | None = None,
+        vault_preset: str | None = None,
+        amount_raw: str | None = None,
+        native_amount_raw: str | None = None,
+    ) -> dict[str, Any]:
+        normalized_operation = _normalize_morpho_vault_operation(operation)
+        resolved_address = await self.get_address()
+        payload: dict[str, Any] = {
+            "walletId": self.wallet_id,
+            "address": resolved_address,
+            "accountIndex": self.account_index,
+            "network": self.network,
+            "tokenAddress": token_address,
+        }
+        if isinstance(vault_address, str) and vault_address.strip():
+            payload["vaultAddress"] = vault_address.strip()
+        if isinstance(vault_preset, str) and vault_preset.strip():
+            payload["vaultPreset"] = vault_preset.strip()
+        if amount_raw is not None:
+            payload["amount"] = amount_raw
+        if native_amount_raw is not None:
+            payload["nativeAmount"] = native_amount_raw
+        data = await self.client.post(
+            f"/v1/evm/morpho/vault/{normalized_operation}/quote",
+            payload,
+        )
+        return _normalize_morpho_payload(
+            chain=self.chain,
+            network=self.network,
+            wallet_id=self.wallet_id,
+            address=resolved_address,
+            operation=normalized_operation,
+            token_address=token_address,
+            amount_raw=amount_raw,
+            native_amount_raw=native_amount_raw,
+            data=data,
+            sign_only=self.sign_only,
+        )
+
+    async def send_evm_morpho_vault_operation(
+        self,
+        *,
+        operation: str,
+        token_address: str,
+        vault_address: str | None = None,
+        vault_preset: str | None = None,
+        amount_raw: str | None = None,
+        native_amount_raw: str | None = None,
+        expected_quote_fingerprint: str | None = None,
+    ) -> dict[str, Any]:
+        if self.sign_only:
+            raise WalletBackendError("wdk_evm_local is configured as sign_only.")
+        normalized_operation = _normalize_morpho_vault_operation(operation)
+        payload: dict[str, Any] = {
+            "walletId": self.wallet_id,
+            "accountIndex": self.account_index,
+            "network": self.network,
+            "tokenAddress": token_address,
+        }
+        if isinstance(vault_address, str) and vault_address.strip():
+            payload["vaultAddress"] = vault_address.strip()
+        if isinstance(vault_preset, str) and vault_preset.strip():
+            payload["vaultPreset"] = vault_preset.strip()
+        if amount_raw is not None:
+            payload["amount"] = amount_raw
+        if native_amount_raw is not None:
+            payload["nativeAmount"] = native_amount_raw
+        if isinstance(expected_quote_fingerprint, str) and expected_quote_fingerprint.strip():
+            payload["expectedQuoteFingerprint"] = expected_quote_fingerprint.strip()
+        data = await self.client.post(
+            f"/v1/evm/morpho/vault/{normalized_operation}/send",
+            payload,
+        )
+        return {
+            **_normalize_morpho_payload(
+                chain=self.chain,
+                network=self.network,
+                wallet_id=self.wallet_id,
+                address=await self.get_address(),
+                operation=normalized_operation,
+                token_address=token_address,
+                amount_raw=amount_raw,
+                native_amount_raw=native_amount_raw,
+                data=data,
+                sign_only=self.sign_only,
+            ),
+            "broadcasted": True,
+            "confirmed": False,
+        }
+
+    async def preview_evm_morpho_market_operation(
+        self,
+        *,
+        operation: str,
+        token_address: str,
+        market_id: str | None = None,
+        market_preset: str | None = None,
+        amount_raw: str | None = None,
+        native_amount_raw: str | None = None,
+    ) -> dict[str, Any]:
+        normalized_operation = _normalize_morpho_market_operation(operation)
+        resolved_address = await self.get_address()
+        payload: dict[str, Any] = {
+            "walletId": self.wallet_id,
+            "address": resolved_address,
+            "accountIndex": self.account_index,
+            "network": self.network,
+            "tokenAddress": token_address,
+        }
+        if isinstance(market_id, str) and market_id.strip():
+            payload["marketId"] = market_id.strip()
+        if isinstance(market_preset, str) and market_preset.strip():
+            payload["marketPreset"] = market_preset.strip()
+        if amount_raw is not None:
+            payload["amount"] = amount_raw
+        if native_amount_raw is not None:
+            payload["nativeAmount"] = native_amount_raw
+        data = await self.client.post(
+            f"/v1/evm/morpho/market/{normalized_operation}/quote",
+            payload,
+        )
+        return _normalize_morpho_payload(
+            chain=self.chain,
+            network=self.network,
+            wallet_id=self.wallet_id,
+            address=resolved_address,
+            operation=normalized_operation,
+            token_address=token_address,
+            amount_raw=amount_raw,
+            native_amount_raw=native_amount_raw,
+            data=data,
+            sign_only=self.sign_only,
+        )
+
+    async def send_evm_morpho_market_operation(
+        self,
+        *,
+        operation: str,
+        token_address: str,
+        market_id: str | None = None,
+        market_preset: str | None = None,
+        amount_raw: str | None = None,
+        native_amount_raw: str | None = None,
+        expected_quote_fingerprint: str | None = None,
+    ) -> dict[str, Any]:
+        if self.sign_only:
+            raise WalletBackendError("wdk_evm_local is configured as sign_only.")
+        normalized_operation = _normalize_morpho_market_operation(operation)
+        payload: dict[str, Any] = {
+            "walletId": self.wallet_id,
+            "accountIndex": self.account_index,
+            "network": self.network,
+            "tokenAddress": token_address,
+        }
+        if isinstance(market_id, str) and market_id.strip():
+            payload["marketId"] = market_id.strip()
+        if isinstance(market_preset, str) and market_preset.strip():
+            payload["marketPreset"] = market_preset.strip()
+        if amount_raw is not None:
+            payload["amount"] = amount_raw
+        if native_amount_raw is not None:
+            payload["nativeAmount"] = native_amount_raw
+        if isinstance(expected_quote_fingerprint, str) and expected_quote_fingerprint.strip():
+            payload["expectedQuoteFingerprint"] = expected_quote_fingerprint.strip()
+        data = await self.client.post(
+            f"/v1/evm/morpho/market/{normalized_operation}/send",
+            payload,
+        )
+        return {
+            **_normalize_morpho_payload(
+                chain=self.chain,
+                network=self.network,
+                wallet_id=self.wallet_id,
+                address=await self.get_address(),
+                operation=normalized_operation,
+                token_address=token_address,
+                amount_raw=amount_raw,
+                native_amount_raw=native_amount_raw,
+                data=data,
+                sign_only=self.sign_only,
+            ),
+            "broadcasted": True,
+            "confirmed": False,
+        }
+
     async def get_evm_swap_quote(
         self,
         *,

package/agent-wallet/openclaw.plugin.json

@@ -2,7 +2,7 @@
   "id": "agent-wallet",
   "name": "Agent Wallet",
   "description": "Plugin-friendly wallet backend for OpenClaw agents with safe wallet tools and runtime instructions across Solana, local BTC, and local EVM.",
-  "version": "0.1.44",
+  "version": "0.1.48",
   "skills": ["skills/wallet-operator"],
   "configSchema": {
     "type": "object",

package/agent-wallet/pyproject.toml

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

package/agent-wallet/scripts/install_agent_wallet.py

@@ -469,6 +469,35 @@ def _replace_with_directory_symlink(link_path: Path, target_path: Path) -> None:
     link_path.symlink_to(target_resolved, target_is_directory=True)
 
 
+def _bootstrap_venv_pip(python_bin: Path) -> None:
+    """Upgrade pip in a freshly created venv before installing dependencies.
+
+    A new venv ships with whatever pip ``ensurepip`` bundled, which on older
+    interpreters (e.g. a python.org 3.10 build) can be too old to select
+    prebuilt wheels for native dependencies such as ``cryptography`` and
+    ``ckzg``. Without a matching wheel pip falls back to a source build that
+    needs a Rust/C toolchain and fails on machines that lack one. Upgrading pip
+    first keeps the editable install below on wheels.
+    """
+    subprocess.run(
+        [str(python_bin), "-m", "pip", "install", "--upgrade", "pip", "setuptools", "wheel"],
+        check=True,
+    )
+
+
+def _pip_install_editable(python_bin: Path, package_root: Path) -> None:
+    """Editable-install the package, preferring prebuilt wheels for deps.
+
+    ``--prefer-binary`` keeps pip on prebuilt wheels for native dependencies
+    instead of compiling them from source when a newer source-only release is
+    available, so the install does not require a local build toolchain.
+    """
+    subprocess.run(
+        [str(python_bin), "-m", "pip", "install", "--prefer-binary", "-e", str(package_root)],
+        check=True,
+    )
+
+
 def _ensure_python_runtime(
     venv_path: Path,
     package_root: Path,
@@ -483,10 +512,8 @@ def _ensure_python_runtime(
         if not python_bin.exists():
             venv.EnvBuilder(with_pip=True).create(shared_venv_path)
             created = True
-            subprocess.run(
-                [str(python_bin), "-m", "pip", "install", "-e", str(package_root)],
-                check=True,
-            )
+            _bootstrap_venv_pip(python_bin)
+            _pip_install_editable(python_bin, package_root)
         shared_wrapper = _ensure_python_wrapper(shared_venv_path)
         _replace_with_directory_symlink(venv_path, shared_venv_path)
         plan["action"] = "create" if created else "reuse"
@@ -501,11 +528,9 @@ def _ensure_python_runtime(
     if not python_bin.exists():
         venv.EnvBuilder(with_pip=True).create(venv_path)
         created = True
+        _bootstrap_venv_pip(python_bin)
 
-    subprocess.run(
-        [str(python_bin), "-m", "pip", "install", "-e", str(package_root)],
-        check=True,
-    )
+    _pip_install_editable(python_bin, package_root)
     return (
         _ensure_python_wrapper(venv_path),
         created,

package/claude-code/plugins/agent-wallet/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "agent-wallet",
   "displayName": "Agent Wallet",
-  "version": "0.1.44",
+  "version": "0.1.48",
   "description": "Claude Code bridge for the existing AgentLayer wallet runtime. Connects to Solana, Bitcoin, and EVM wallets without creating a new one.",
   "author": {
     "name": "AgentLayer"

package/codex/plugins/agent-wallet/.codex-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-wallet",
-  "version": "0.1.44",
+  "version": "0.1.48",
   "description": "Codex plugin bridge for the AgentLayer wallet runtime.",
   "author": {
     "name": "AgentLayer"

package/hermes/plugins/agent_wallet/plugin.yaml

@@ -1,5 +1,5 @@
 name: agent-wallet
-version: 0.1.44
+version: 0.1.48
 description: Thin Hermes Agent bridge to the existing AgentLayer/OpenClaw wallet backend
 provides_tools:
   - agent_wallet_tools

package/package.json

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

package/wdk-btc-wallet/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wdk-btc-wallet",
-  "version": "0.1.44",
+  "version": "0.1.48",
   "private": true,
   "type": "module",
   "description": "Separate BTC-only wallet service built on Tether WDK.",

package/wdk-evm-wallet/README.md

@@ -26,6 +26,11 @@ Current scope:
 - fetch Aave V3 reserve catalog on supported mainnet networks
 - fetch Aave V3 per-reserve user positions on supported mainnet networks
 - quote and send narrow Aave V3 `supply`, `withdraw`, `borrow`, and `repay` operations
+- fetch Morpho vault discovery and detail data on supported mainnet networks
+- fetch Morpho market discovery and detail data on supported mainnet networks
+- fetch Morpho user vault and market positions on supported mainnet networks
+- quote and send narrow Morpho vault `supply` and `withdraw` operations
+- quote and send narrow Morpho market `supply_collateral`, `borrow`, `repay`, and `withdraw_collateral` operations
 - quote and send native transfers
 - quote and send ERC-20 transfers
 - fetch transaction receipts
@@ -41,6 +46,8 @@ The implementation follows the official WDK documentation:
 - Velora swap API reference: https://docs.wdk.tether.io/sdk/swap-modules/swap-velora-evm/api-reference
 - Aave lending overview: https://docs.wdk.tether.io/sdk/lending-modules/lending-aave-evm
 - Aave lending API reference: https://docs.wdk.tether.io/sdk/lending-modules/lending-aave-evm/api-reference
+- Morpho Build overview: https://morpho.org/build
+- Morpho offchain API docs: https://docs.morpho.org/tools/offchain/api/get-started/
 
 ## Why Separate
 
@@ -101,6 +108,21 @@ The active network is persistent and can be switched without changing code.
 - `POST /v1/evm/aave/borrow/send`
 - `POST /v1/evm/aave/repay/quote`
 - `POST /v1/evm/aave/repay/send`
+- `POST /v1/evm/morpho/vaults/get`
+- `POST /v1/evm/morpho/markets/get`
+- `POST /v1/evm/morpho/positions/get`
+- `POST /v1/evm/morpho/vault/supply/quote`
+- `POST /v1/evm/morpho/vault/supply/send`
+- `POST /v1/evm/morpho/vault/withdraw/quote`
+- `POST /v1/evm/morpho/vault/withdraw/send`
+- `POST /v1/evm/morpho/market/supply_collateral/quote`
+- `POST /v1/evm/morpho/market/supply_collateral/send`
+- `POST /v1/evm/morpho/market/borrow/quote`
+- `POST /v1/evm/morpho/market/borrow/send`
+- `POST /v1/evm/morpho/market/repay/quote`
+- `POST /v1/evm/morpho/market/repay/send`
+- `POST /v1/evm/morpho/market/withdraw_collateral/quote`
+- `POST /v1/evm/morpho/market/withdraw_collateral/send`
 - `POST /v1/evm/swap/quote`
 - `POST /v1/evm/swap/send`
 - `POST /v1/evm/uniswap/swap/quote`
@@ -162,11 +184,20 @@ Environment variables:
 - `WDK_EVM_SEPOLIA_RPC_URL`
 - `WDK_EVM_BASE_RPC_URL`
 - `WDK_EVM_BASE_SEPOLIA_RPC_URL`
+- `MORPHO_API_BASE_URL`
 - `UNISWAP_API_KEY`
 - `UNISWAP_TRADING_API_BASE_URL`
 - `UNISWAP_ROUTER_VERSION`
 - `UNISWAP_DEFAULT_SLIPPAGE_BPS`
 
+Morpho read-only support:
+
+- the runtime exposes Morpho discovery and account-read routes through the public
+  Morpho GraphQL API at `https://api.morpho.org/graphql` by default
+- Morpho support is currently limited to `ethereum` and `base` mainnet
+- vault and market discovery use fixed first-party queries rather than caller-provided
+  GraphQL strings
+
 Swap providers:
 
 - the runtime exposes three independent swap surfaces: Velora (`/v1/evm/swap/*`),