ipor-fusion 4.0.0.dev222__tar.gz → 4.0.0.dev231__tar.gz

{ipor_fusion-4.0.0.dev222 → ipor_fusion-4.0.0.dev231}/AGENTS.md

@@ -533,6 +533,11 @@ decoder adds its own fields.
 - `ZeroBalanceFuse` markets are capabilities (swap, flash-loan,
   instant-withdrawal, admin) with structurally zero balance, not venues. They
   go in `zero_balance_fuses` and are not counted as liquidity markets.
+- A validation input that cannot be read is never a silent `ok`: a lending
+  position whose reads fail is an `UnreadableLendingMarket` (a `lending_health`
+  warning), a failed lending-health or unpriceable-token read is named in
+  `VaultData.failed_reads` (an `incomplete_read` warning). Catch the chain and
+  transport errors only; degrade-to-`None` is for display-only data.
 - Reconciliation: `totalAssets = balance_fuses_sum + underlying_on_vault +
   rewards_manager_balance` (`PlasmaVault._getGrossTotalAssets` adds
   `IRewardsClaimManager.balanceOf()`, the vested rewards, when a manager is set;

{ipor_fusion-4.0.0.dev222 → ipor_fusion-4.0.0.dev231}/MIGRATION_4.md

@@ -990,6 +990,31 @@ and `log_index` was passed through as given (a hex string from a raw log); the e
 These apply to every caller, type-checked or not. Changes described in full above
 are listed with a link.
 
+- **A failed lending read is a warning, never a silent `ok`.** 3.x caught every
+  exception in the lending-health readers and dropped the position, so a provider
+  outage could leave no lending finding and an `ok` verdict. Now:
+  - A position whose reads fail with a chain or transport error (revert, RPC,
+    timeout, no or malformed data) becomes an `UnreadableLendingMarket` in
+    `VaultLendingHealth.unreadable`.
+  - Each unreadable position is a `lending_health` warning.
+  - An Aave V3 market whose Pool could not be resolved is listed the same way
+    instead of being skipped.
+  - Any other exception propagates.
+  - When the whole lending-health read or the unpriceable-token check fails with
+    a revert, an RPC error or a timeout, `VaultData.failed_reads` names it and
+    validation reports an `incomplete_read` warning. A transport failure (no
+    connection) still aborts the fetch rather than return a snapshot.
+  - A substrate the unpriceable-token check could not cover is named the same
+    way (`unpriceable_priced_tokens: <what>`). Examples: a Morpho position whose
+    read failed, or a reverting `asset()` / `getSilos()`.
+    `fetch_unpriceable_priced_tokens` returns an `UnpriceableCheck` (`tokens`,
+    `unread`) instead of a bare list.
+
+  The `lending_health` JSON block of `vault info` and `vault validate` carries
+  `unreadable`, and a custom `VaultState` adds the `failed_reads` property. A
+  position missing from the breakdown tables is shown as absent, while the
+  checks it feeds report it.
+
 - **More markets decode their substrates.** VELODROME_SUPERCHAIN (31, Gauge /
   Pool), AGUA_GLOBAL_CARRY (51, VAULT / ASSET), TERM_FINANCE (52, SERVICER address
   or COLLATERAL_TOKEN pair key), META_MORPHO_0001, MERKL and

{ipor_fusion-4.0.0.dev222 → ipor_fusion-4.0.0.dev231}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: ipor-fusion
-Version: 4.0.0.dev222
+Version: 4.0.0.dev231
 Summary: The IPOR Fusion SDK for Python
 Project-URL: homepage, https://ipor.io
 Project-URL: repository, https://github.com/IPOR-Labs/ipor-fusion.py

{ipor_fusion-4.0.0.dev222 → ipor_fusion-4.0.0.dev231}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "ipor-fusion"
-version = "4.0.0.dev222"
+version = "4.0.0.dev231"
 description = "The IPOR Fusion SDK for Python"
 authors = [
     { name = "Adam Mydlarz", email = "amydlarz@gmail.com" },

{ipor_fusion-4.0.0.dev222 → ipor_fusion-4.0.0.dev231}/src/ipor_fusion/__init__.py

@@ -275,6 +275,8 @@ from ipor_fusion.readers import (
     RamsesV2Reader,
     UniswapV3Position,
     UniswapV3Reader,
+    UnpriceableCheck,
+    UnreadableLendingMarket,
     VaultLendingHealth,
     build_oracle_mapping,
     fetch_unpriceable_priced_tokens,
@@ -385,6 +387,7 @@ from ipor_fusion.vault_info import (
     ReconciliationJson,
     SharePriceJson,
     SubstrateEntryJson,
+    UnreadableLendingMarketJson,
     UsdAmountJson,
     VaultAssetJson,
     VaultInfoJson,
@@ -631,6 +634,7 @@ __all__ = [
     "HYPEREVM_CHAIN_ID",
     "LendingMarketHealth",
     "VaultLendingHealth",
+    "UnreadableLendingMarket",
     "fetch_vault_lending_health",
     "OracleAsset",
     "OracleMapping",
@@ -651,6 +655,7 @@ __all__ = [
     "build_oracle_mapping",
     "OracleMappingReader",
     "MiddlewarePricedToken",
+    "UnpriceableCheck",
     "fetch_unpriceable_priced_tokens",
     "PositionData",
     "UniswapV3Reader",
@@ -701,6 +706,7 @@ __all__ = [
     "HyperCorePerpMarketJson",
     "HyperCoreSpotLegJson",
     "LendingHealthJson",
+    "UnreadableLendingMarketJson",
     "LendingMarketJson",
     "ManagersJson",
     "MorphoBreakdownJson",

{ipor_fusion-4.0.0.dev222 → ipor_fusion-4.0.0.dev231}/src/ipor_fusion/cli/vault_markets_view.py

@@ -95,6 +95,17 @@ def _print_lending_health(data: VaultData) -> None:  # noqa: C901
             if m.protocol == "aave_v4":
                 click.echo(f"    spoke {m.substrate_id}:")
             _print_health_lines(m, indent="    ")
+    _print_unreadable_health(lh)
+
+
+def _print_unreadable_health(lh: VaultLendingHealth | None) -> None:
+    for u in lh.unreadable if lh is not None else []:
+        where = f" {u.substrate_id}" if u.substrate_id else ""
+        click.secho(
+            f"  {format_market_label(u.market_id)}: {u.protocol}{where} "
+            f"health unknown — {u.reason}",
+            fg="yellow",
+        )
 
 
 def _index_lending_health(

{ipor_fusion-4.0.0.dev222 → ipor_fusion-4.0.0.dev231}/src/ipor_fusion/mcp/models.py

@@ -431,8 +431,20 @@ class LendingMarketHealth(_Base):
     is_critical: bool
 
 
+class UnreadableLendingMarket(_Base):
+    """A lending position whose health could not be read: unknown, not
+    healthy."""
+
+    protocol: str
+    market_id: MarketId
+    market_name: str
+    substrate_id: str | None
+    reason: str
+
+
 class LendingHealth(_Base):
     markets: list[LendingMarketHealth]
+    unreadable: list[UnreadableLendingMarket] = Field(default_factory=list)
     worst_ltv_usage_percent: float | None
 
 
@@ -875,12 +887,25 @@ class LendingMarketModel(_Base):
 
 class LendingHealthModel(_Base):
     markets: list[LendingMarketModel]
+    unreadable: list[UnreadableLendingMarket] = Field(
+        description="Positions whose health could not be read: unknown, not healthy."
+    )
     worst_ltv_usage_percent: float | None
 
     @classmethod
     def from_health(cls, health: VaultLendingHealth) -> LendingHealthModel:
         return cls(
             markets=[LendingMarketModel.from_market(m) for m in health.markets],
+            unreadable=[
+                UnreadableLendingMarket(
+                    protocol=u.protocol,
+                    market_id=u.market_id,
+                    market_name=u.market_name,
+                    substrate_id=u.substrate_id,
+                    reason=u.reason,
+                )
+                for u in health.unreadable
+            ],
             worst_ltv_usage_percent=health.worst_ltv_usage,
         )
 

{ipor_fusion-4.0.0.dev222 → ipor_fusion-4.0.0.dev231}/src/ipor_fusion/readers/__init__.py

@@ -17,6 +17,7 @@ from ipor_fusion.readers.hypercore import (
 )
 from ipor_fusion.readers.lending_health import (
     LendingMarketHealth,
+    UnreadableLendingMarket,
     VaultLendingHealth,
     fetch_vault_lending_health,
 )
@@ -56,6 +57,7 @@ from ipor_fusion.readers.ramses_v2 import RamsesV2Position, RamsesV2Reader
 from ipor_fusion.readers.uniswap_v3 import UniswapV3Position, UniswapV3Reader
 from ipor_fusion.readers.unpriceable import (
     MiddlewarePricedToken,
+    UnpriceableCheck,
     fetch_unpriceable_priced_tokens,
 )
 
@@ -80,6 +82,7 @@ __all__ = [
     "HYPEREVM_CHAIN_ID",
     "LendingMarketHealth",
     "VaultLendingHealth",
+    "UnreadableLendingMarket",
     "fetch_vault_lending_health",
     "OracleAsset",
     "OracleMapping",
@@ -100,6 +103,7 @@ __all__ = [
     "build_oracle_mapping",
     "OracleMappingReader",
     "MiddlewarePricedToken",
+    "UnpriceableCheck",
     "fetch_unpriceable_priced_tokens",
     "PositionData",
     "UniswapV3Reader",

{ipor_fusion-4.0.0.dev222 → ipor_fusion-4.0.0.dev231}/src/ipor_fusion/readers/lending_health.py

@@ -8,15 +8,25 @@ from __future__ import annotations
 
 import logging
 from concurrent.futures import ThreadPoolExecutor
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 
+import requests
 from eth_abi import decode
+from eth_abi.exceptions import DecodingError
 from eth_typing import ChecksumAddress
 from eth_utils import function_signature_to_4byte_selector
 from web3 import Web3
+from web3.exceptions import (
+    BadFunctionCallOutput,
+    ContractLogicError,
+    ProviderConnectionError,
+    TimeExhausted,
+    Web3RPCError,
+)
 
 from ipor_fusion.core.context import Web3Context
 from ipor_fusion.core.multicall import Multicall3
+from ipor_fusion.errors import EmptyCallResultError
 from ipor_fusion.market_ids import IporFusionMarkets
 from ipor_fusion.readers.aave_v3 import AaveV3Reader
 from ipor_fusion.readers.aave_v4 import AaveV4OracleReader, AaveV4SpokeReader
@@ -36,6 +46,19 @@ from ipor_fusion.types import (
 
 _logger = logging.getLogger(__name__)
 
+# What a lending read can fail with that is about the chain, not the code:
+# reverts, RPC and transport errors, a contract answering no or malformed data.
+_READ_ERRORS = (
+    ContractLogicError,
+    Web3RPCError,
+    TimeExhausted,
+    BadFunctionCallOutput,
+    ProviderConnectionError,
+    requests.RequestException,
+    EmptyCallResultError,
+    DecodingError,
+)
+
 WAD = 10**18
 RAY = 10**27
 ORACLE_PRICE_SCALE = 10**36
@@ -121,15 +144,35 @@ class LendingMarketHealth:
         return self.health_factor <= 1.05
 
 
+@dataclass(slots=True)
+class UnreadableLendingMarket:
+    """A lending position whose health could not be read: it is unknown, not
+    healthy. ``substrate_id`` as in `LendingMarketHealth`."""
+
+    protocol: str
+    market_id: MarketId
+    market_name: str
+    reason: str
+    substrate_id: str | None = None
+
+
 @dataclass(slots=True)
 class VaultLendingHealth:
-    """Aggregated lending health for all lending markets in a vault."""
+    """Aggregated lending health for all lending markets in a vault.
+
+    ``unreadable`` lists the positions whose reads failed; the health is
+    complete only when it is empty."""
 
     markets: list[LendingMarketHealth]
+    unreadable: list[UnreadableLendingMarket] = field(default_factory=list)
 
     @property
     def has_lending_positions(self) -> bool:
-        return len(self.markets) > 0
+        return len(self.markets) > 0 or len(self.unreadable) > 0
+
+    @property
+    def is_complete(self) -> bool:
+        return not self.unreadable
 
     @property
     def worst_ltv_usage(self) -> float | None:
@@ -137,6 +180,12 @@ class VaultLendingHealth:
         return max(usages) if usages else None
 
 
+def _reason(what: str, exc: Exception) -> str:
+    """Why a read failed, for the unreadable entry and its finding."""
+    _logger.debug("lending %s read failed: %s: %s", what, type(exc).__name__, exc)
+    return f"{what} read failed: {type(exc).__name__}"
+
+
 def _call_morpho_oracle_price(ctx: Web3Context, oracle_address: ChecksumAddress) -> int:
     """Call IOracle(oracle).price() -> uint256."""
     selector = function_signature_to_4byte_selector("price()")
@@ -152,7 +201,7 @@ def _compute_morpho_market_health(
     vault_address: PlasmaVaultAddress,
     ipor_market_id: MarketId,
     market_name: str,
-) -> LendingMarketHealth | None:
+) -> LendingMarketHealth | UnreadableLendingMarket:
     """Compute LTV health for a single Morpho Blue market position."""
     batch = Multicall3(ctx).batch()
     position_read = batch.add(reader.position(morpho_market_id, vault_address))
@@ -160,9 +209,14 @@ def _compute_morpho_market_health(
     params_read = batch.add(reader.market_params(morpho_market_id))
     try:
         batch.run()
-    except Exception:
-        _logger.debug("Failed to read Morpho market data for %s", morpho_market_id)
-        return None
+    except _READ_ERRORS as exc:
+        return UnreadableLendingMarket(
+            protocol="morpho",
+            market_id=ipor_market_id,
+            market_name=market_name,
+            reason=_reason("market data", exc),
+            substrate_id=morpho_market_id,
+        )
     position, market, params = (
         position_read.value,
         market_read.value,
@@ -186,9 +240,14 @@ def _compute_morpho_market_health(
 
     try:
         oracle_price = _call_morpho_oracle_price(ctx, params.oracle)
-    except Exception:
-        _logger.debug("Failed to read Morpho oracle price for %s", morpho_market_id)
-        return None
+    except _READ_ERRORS as exc:
+        return UnreadableLendingMarket(
+            protocol="morpho",
+            market_id=ipor_market_id,
+            market_name=market_name,
+            reason=_reason("oracle price", exc),
+            substrate_id=morpho_market_id,
+        )
 
     borrowed = to_assets_up(
         position.borrow_shares, market.total_borrow_assets, market.total_borrow_shares
@@ -246,13 +305,18 @@ def _compute_aave_market_health(
     vault_address: PlasmaVaultAddress,
     ipor_market_id: MarketId,
     market_name: str,
-) -> LendingMarketHealth | None:
+) -> LendingMarketHealth | UnreadableLendingMarket:
     """Compute LTV health for the vault's Aave V3 position."""
     try:
         data = reader.get_user_account_data(vault_address).call(ctx)
-    except Exception:
-        _logger.debug("Failed to read Aave V3 account data for %s", vault_address)
-        return None
+    except _READ_ERRORS as exc:
+        return UnreadableLendingMarket(
+            protocol="aave_v3",
+            market_id=ipor_market_id,
+            market_name=market_name,
+            reason=_reason("account data", exc),
+            substrate_id=None,
+        )
 
     # No debt = no risk
     if data.total_debt_base == 0:
@@ -300,16 +364,21 @@ def _compute_aave_v4_market_health(
     vault_address: PlasmaVaultAddress,
     ipor_market_id: MarketId,
     market_name: str,
-) -> LendingMarketHealth | None:
+) -> LendingMarketHealth | UnreadableLendingMarket:
     """Compute LTV health for the vault's account on one Aave V4 Spoke."""
     reader = AaveV4SpokeReader(spoke)
     try:
         data = reader.get_user_account_data(vault_address).call(ctx)
         oracle_decimals = AaveV4OracleReader(reader.oracle().call(ctx)).decimals()
         value_scale = 10 ** (oracle_decimals.call(ctx) + 18)
-    except Exception:
-        _logger.debug("Failed to read Aave V4 account data on spoke %s", spoke)
-        return None
+    except _READ_ERRORS as exc:
+        return UnreadableLendingMarket(
+            protocol="aave_v4",
+            market_id=ipor_market_id,
+            market_name=market_name,
+            reason=_reason("account data", exc),
+            substrate_id=spoke,
+        )
 
     max_ltv = data.avg_collateral_factor / WAD
     current_ltv: float | None
@@ -355,6 +424,7 @@ class _LendingMarkets:
     morpho: list[tuple[MarketId, str, MorphoBlueMarketId]]
     aave_v3: list[tuple[MarketId, str, ChecksumAddress]]
     aave_v4: list[tuple[MarketId, str, ChecksumAddress]]
+    unreadable: list[UnreadableLendingMarket]
 
 
 def _collect_lending_markets(
@@ -364,7 +434,7 @@ def _collect_lending_markets(
 ) -> _LendingMarkets:
     """Pick the positions to read: Morpho substrates, Aave V3 markets with a Pool,
     and the Spokes of Aave V4 markets."""
-    markets = _LendingMarkets(morpho=[], aave_v3=[], aave_v4=[])
+    markets = _LendingMarkets(morpho=[], aave_v3=[], aave_v4=[], unreadable=[])
 
     for mid in balance_fuse_market_ids:
         name = market_name(mid)
@@ -377,7 +447,14 @@ def _collect_lending_markets(
             if aave_pool := aave_pools.get(mid):
                 markets.aave_v3.append((mid, name, aave_pool))
             else:
-                _logger.debug("No Aave V3 pool for market %d, skipping", mid)
+                markets.unreadable.append(
+                    UnreadableLendingMarket(
+                        protocol="aave_v3",
+                        market_id=mid,
+                        market_name=name,
+                        reason="the balance fuse's Aave V3 Pool could not be read",
+                    )
+                )
         elif mid in AAVE_V4_MARKET_IDS:
             for spoke in _aave_v4_spokes(market_substrates.get(mid, [])):
                 markets.aave_v4.append((mid, name, spoke))
@@ -402,8 +479,8 @@ def fetch_vault_lending_health(
         market_substrates: Map of market_id -> list of raw substrate bytes.
             Morpho market ids and Aave V4 Spokes are read from it.
         aave_pools: Map of Aave V3 market_id -> the Pool its balance fuse
-            reads (`AaveV3FuseReader.pool`). Aave V3 markets without an entry
-            are skipped. Defaults to the chain's Core pool for AAVE_V3 only:
+            reads (`AaveV3FuseReader.pool`). An Aave V3 market without an
+            entry is listed in ``unreadable``. Defaults to the chain's Core pool for AAVE_V3 only:
             the Pools of Aave V3 Prime and SparkLend are known only to their
             fuses.
     """
@@ -416,6 +493,7 @@ def fetch_vault_lending_health(
     )
 
     results: list[LendingMarketHealth] = []
+    unreadable = list(markets.unreadable)
 
     with ThreadPoolExecutor() as pool:
         futures = []
@@ -462,7 +540,9 @@ def fetch_vault_lending_health(
 
         for fut in futures:
             result = fut.result()
-            if result is not None:
+            if isinstance(result, UnreadableLendingMarket):
+                unreadable.append(result)
+            else:
                 results.append(result)
 
-    return VaultLendingHealth(markets=results)
+    return VaultLendingHealth(markets=results, unreadable=unreadable)

{ipor_fusion-4.0.0.dev222 → ipor_fusion-4.0.0.dev231}/src/ipor_fusion/readers/unpriceable.py

@@ -11,7 +11,7 @@ triggers it.
 from __future__ import annotations
 
 from collections.abc import Iterable
-from dataclasses import dataclass, replace
+from dataclasses import dataclass, field, replace
 
 from eth_utils import function_signature_to_4byte_selector
 from web3 import Web3
@@ -171,8 +171,21 @@ def _morpho_tokens(
     ]
 
 
+@dataclass(frozen=True)
+class UnpriceableCheck:
+    """`fetch_unpriceable_priced_tokens`: the flagged ``tokens``, and in
+    ``unread`` the granted substrates whose priced token could not be found
+    (a reverting ``asset()`` or ``getSilos()``): the check is complete only
+    when it is empty."""
+
+    tokens: list[MiddlewarePricedToken]
+    unread: list[str] = field(default_factory=list)
+
+
 def _vault_asset_tokens(
-    ctx: Web3Context, market_substrates: dict[MarketId, list[bytes]]
+    ctx: Web3Context,
+    market_substrates: dict[MarketId, list[bytes]],
+    unread: list[str],
 ) -> list[MiddlewarePricedToken]:
     """``asset()`` of granted ERC4626 vaults (Euler V2, generic ERC4626) and
     of both silos of every granted Silo Config. All three fuses price it
@@ -196,6 +209,11 @@ def _vault_asset_tokens(
     multicall = Multicall3(ctx)
     if configs:
         silo_pairs = multicall.try_aggregate([_silos_call(c) for c in configs])
+        unread += [
+            f"getSilos() of granted Silo Config {config}"
+            for config, silos in zip(configs, silo_pairs, strict=True)
+            if silos is None
+        ]
         vaults += [
             (
                 IporFusionMarkets.SILO_V2,
@@ -211,6 +229,9 @@ def _vault_asset_tokens(
     assets = multicall.try_aggregate(
         [_address_call(vault, _ASSET_SELECTOR) for _, vault, _ in vaults]
     )
+    unread += [
+        via for (_, _, via), asset in zip(vaults, assets, strict=True) if asset is None
+    ]
     return [
         MiddlewarePricedToken(
             market_id,
@@ -293,17 +314,20 @@ def fetch_unpriceable_priced_tokens(
     balance_fuses: list[BalanceFuse],
     market_substrates: dict[MarketId, list[bytes]],
     morpho_positions: dict[MarketId, list[MorphoPositionBreakdown]] | None,
-) -> list[MiddlewarePricedToken]:
+) -> UnpriceableCheck:
     """Every middleware-priced token of a granted substrate the middleware
-    cannot price, in market order."""
+    cannot price, in market order, and the substrates whose token could not
+    be found. ``morpho_positions`` must hold every Morpho substrate: a
+    position left out is a token left unchecked."""
+    unread: list[str] = []
     priced = [
         *_plain_tokens(market_substrates, Web3.to_checksum_address(underlying)),
         *_morpho_tokens(morpho_positions),
-        *_vault_asset_tokens(ctx, market_substrates),
+        *_vault_asset_tokens(ctx, market_substrates, unread),
         *_aave_v3_middleware_tokens(ctx, balance_fuses, market_substrates),
     ]
     if not priced:
-        return []
+        return UnpriceableCheck(tokens=[], unread=unread)
     oracle = price_oracle_middleware(ctx, Web3.to_checksum_address(price_oracle))
     unpriceable = _unpriceable(ctx, oracle, (p.token for p in priced))
     flagged = {
@@ -311,4 +335,6 @@ def fetch_unpriceable_priced_tokens(
         for p in priced
         if p.token in unpriceable
     }
-    return [flagged[key] for key in sorted(flagged)]
+    return UnpriceableCheck(
+        tokens=[flagged[key] for key in sorted(flagged)], unread=unread
+    )

{ipor_fusion-4.0.0.dev222 → ipor_fusion-4.0.0.dev231}/src/ipor_fusion/types.py

@@ -84,6 +84,7 @@ Check: TypeAlias = Literal[
     "missing_erc20_dependency",
     "unpriceable_token",
     "lending_health",
+    "incomplete_read",
     "total_assets_reconciliation",
     "pending_withdrawals",
     "market_storage_drift",

{ipor_fusion-4.0.0.dev222 → ipor_fusion-4.0.0.dev231}/src/ipor_fusion/validation.py

@@ -153,6 +153,12 @@ class VaultState(Protocol):
     def unpriceable_priced_tokens(self) -> Sequence[UnpriceableToken] | None: ...
     @property
     def unimplemented_getters(self) -> Sequence[str]: ...
+    @property
+    def failed_reads(self) -> Sequence[str]:
+        """Validation inputs whose read failed (``lending_health``,
+        ``unpriceable_priced_tokens``): their checks did not run."""
+        ...
+
     @property
     def market_balances(self) -> Mapping[MarketId, Amount]: ...
     @property
@@ -291,6 +297,7 @@ def validate_vault_state(state: VaultState) -> VaultValidation:
         *_missing_erc20_dependency_findings(state),
         *_unpriceable_token_findings(state),
         *_lending_health_findings(state),
+        *_failed_read_findings(state),
         *_reconciliation_findings(state, reconciliation),
         *_erc20_findings(state, state.erc20),
     ]
@@ -550,11 +557,43 @@ def _unpriceable_token_finding(token: UnpriceableToken) -> Finding:
     )
 
 
+_FAILED_READ_IMPACT = {
+    "lending_health": "the liquidation risk of the lending positions is unknown",
+    "unpriceable_priced_tokens": "tokens the price oracle cannot price were not "
+    "looked for",
+}
+
+
+def _failed_read_findings(state: VaultState) -> list[Finding]:
+    findings = []
+    for read in state.failed_reads:
+        name, _, detail = read.partition(": ")
+        what = f"{name} ({detail})" if detail else name
+        impact = _FAILED_READ_IMPACT.get(name, "its check did not run")
+        findings.append(
+            Finding(
+                "incomplete_read",
+                "warning",
+                f"WARNING — {what} could not be read: {impact}",
+            )
+        )
+    return findings
+
+
 def _lending_health_findings(state: VaultState) -> list[Finding]:
     health = state.lending_health
     if not health or not health.has_lending_positions:
         return []
-    findings: list[Finding] = []
+    findings = [
+        Finding(
+            "lending_health",
+            "warning",
+            f"WARNING — {u.protocol} {u.market_name}"
+            f"{f' ({u.substrate_id})' if u.substrate_id else ''}: health unknown, "
+            f"{u.reason}",
+        )
+        for u in health.unreadable
+    ]
     for market in health.markets:
         if market.ltv_usage_percent is None:
             continue