ipor-fusion 4.2.0.dev11__tar.gz → 4.2.0.dev14__tar.gz

{ipor_fusion-4.2.0.dev11 → ipor_fusion-4.2.0.dev14}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: ipor-fusion
-Version: 4.2.0.dev11
+Version: 4.2.0.dev14
 Summary: The IPOR Fusion SDK for Python
 Project-URL: homepage, https://ipor.io
 Project-URL: repository, https://github.com/IPOR-Labs/ipor-fusion.py
@@ -564,7 +564,7 @@ Read-only aggregators over positions and health, no fuses involved:
 |--------|---------|
 | `MorphoReader`, `AaveV3Reader`, `CompoundV3Reader` | Market params, rates and vault positions per lending protocol |
 | `UniswapV3Reader`, `RamsesV2Reader` | LP position details |
-| `fetch_vault_lending_health` | Health factor per lending market a vault is in (Morpho, Aave V3/V4, Euler V2; any other market that can borrow is listed as unreadable) |
+| `fetch_vault_lending_health` | Health factor per lending market a vault is in (Morpho, Aave V3/V4, Euler V2, Compound V3; any other market that can borrow is listed as unreadable) |
 | `build_oracle_mapping` | How the vault prices every configured asset |
 
 ### Supported networks

{ipor_fusion-4.2.0.dev11 → ipor_fusion-4.2.0.dev14}/README.md

@@ -515,7 +515,7 @@ Read-only aggregators over positions and health, no fuses involved:
 |--------|---------|
 | `MorphoReader`, `AaveV3Reader`, `CompoundV3Reader` | Market params, rates and vault positions per lending protocol |
 | `UniswapV3Reader`, `RamsesV2Reader` | LP position details |
-| `fetch_vault_lending_health` | Health factor per lending market a vault is in (Morpho, Aave V3/V4, Euler V2; any other market that can borrow is listed as unreadable) |
+| `fetch_vault_lending_health` | Health factor per lending market a vault is in (Morpho, Aave V3/V4, Euler V2, Compound V3; any other market that can borrow is listed as unreadable) |
 | `build_oracle_mapping` | How the vault prices every configured asset |
 
 ### Supported networks

{ipor_fusion-4.2.0.dev11 → ipor_fusion-4.2.0.dev14}/pyproject.toml

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

{ipor_fusion-4.2.0.dev11 → ipor_fusion-4.2.0.dev14}/src/ipor_fusion/__init__.py

@@ -312,6 +312,9 @@ from ipor_fusion.readers import (
     AaveV4OracleReader,
     AaveV4SpokeReader,
     AaveV4UserAccountData,
+    CometAccountValue,
+    CometAssetInfo,
+    CompoundV3FuseReader,
     CompoundV3Reader,
     LendingMarketHealth,
     MiddlewarePricedToken,
@@ -788,6 +791,9 @@ __all__ = [
     "AaveV4OracleReader",
     "AaveV4SpokeReader",
     "AaveV4UserAccountData",
+    "CometAccountValue",
+    "CometAssetInfo",
+    "CompoundV3FuseReader",
     "CompoundV3Reader",
     "HYPEREVM_CHAIN_ID",
     "LendingMarketHealth",

{ipor_fusion-4.2.0.dev11 → ipor_fusion-4.2.0.dev14}/src/ipor_fusion/cli/vault_markets_view.py

@@ -116,8 +116,8 @@ def _index_lending_health(
     """Split lending health rows by protocol for fast lookup during rendering.
 
     Morpho rows are keyed by morpho substrate id (one row per substrate).
-    Aave V3 rows are keyed by IPOR market id (account-aggregated, one row per
-    market); Aave V4 rows by Spoke address (account-aggregated per Spoke) and
+    Aave V3 and Compound V3 rows are keyed by IPOR market id (account-aggregated,
+    one row per market); Aave V4 rows by Spoke address (account-aggregated per Spoke) and
     Euler V2 rows by sub-account address, in the same account-level map.
     """
     morpho: dict[str, LendingMarketHealth] = {}
@@ -127,7 +127,7 @@ def _index_lending_health(
     for m in lh.markets:
         if m.protocol == "morpho" and m.substrate_id:
             morpho[str(m.substrate_id).lower().removeprefix("0x")] = m
-        elif m.protocol == "aave_v3":
+        elif m.protocol in ("aave_v3", "compound_v3"):
             aave[m.market_id] = m
         elif m.protocol in ("aave_v4", "euler_v2") and m.substrate_id:
             aave[m.substrate_id] = m

{ipor_fusion-4.2.0.dev11 → ipor_fusion-4.2.0.dev14}/src/ipor_fusion/readers/__init__.py

@@ -11,7 +11,12 @@ from ipor_fusion.readers.aave_v4 import (
     AaveV4SpokeReader,
     AaveV4UserAccountData,
 )
-from ipor_fusion.readers.compound_v3 import CompoundV3Reader
+from ipor_fusion.readers.compound_v3 import (
+    CometAccountValue,
+    CometAssetInfo,
+    CompoundV3FuseReader,
+    CompoundV3Reader,
+)
 from ipor_fusion.readers.hypercore import (
     HYPEREVM_CHAIN_ID,
 )
@@ -79,6 +84,9 @@ __all__ = [
     "AaveV4OracleReader",
     "AaveV4SpokeReader",
     "AaveV4UserAccountData",
+    "CometAccountValue",
+    "CometAssetInfo",
+    "CompoundV3FuseReader",
     "CompoundV3Reader",
     "HYPEREVM_CHAIN_ID",
     "LendingMarketHealth",

ipor_fusion-4.2.0.dev14/src/ipor_fusion/readers/compound_v3.py

@@ -0,0 +1,164 @@
+from dataclasses import dataclass
+
+from eth_typing import ChecksumAddress
+from web3 import Web3
+
+from ipor_fusion.core.context import Web3Context
+from ipor_fusion.core.contract import Call, ContractWrapper
+from ipor_fusion.core.multicall import Multicall3
+from ipor_fusion.types import Amount
+
+COMET_FACTOR_SCALE = 10**18
+COMET_PRICE_SCALE = 10**8
+
+
+@dataclass(frozen=True, slots=True)
+class CometAssetInfo:
+    """A collateral listing of a Comet; the factors are scaled by 1e18."""
+
+    asset: ChecksumAddress
+    price_feed: ChecksumAddress
+    scale: int
+    borrow_collateral_factor: int
+    liquidate_collateral_factor: int
+
+
+@dataclass(frozen=True, slots=True)
+class CometAccountValue:
+    """An account's position in the Comet's own prices, scaled by 1e8.
+
+    The unit is the Comet's price unit: USD on USD-priced Comets, ETH on a WETH
+    Comet. ``liquidation_limit`` is the collateral at its liquidation factors;
+    the account is liquidatable when ``debt`` exceeds it.
+    """
+
+    collateral: int
+    liquidation_limit: int
+    debt: int
+
+
+def _asset_info_decoder(
+    value: tuple[int, str, str, int, int, int, int, int],
+) -> CometAssetInfo:
+    _, asset, price_feed, scale, borrow_factor, liquidate_factor, _, _ = value
+    return CometAssetInfo(
+        asset=Web3.to_checksum_address(asset),
+        price_feed=Web3.to_checksum_address(price_feed),
+        scale=scale,
+        borrow_collateral_factor=borrow_factor,
+        liquidate_collateral_factor=liquidate_factor,
+    )
+
+
+class CompoundV3FuseReader(ContractWrapper):
+    """Reader for the immutables of an IPOR Fusion Compound V3 fuse.
+
+    A Fusion market is bound to one Comet per chain through its fuses, so the
+    Comet behind a market is a property of its fuse.
+    """
+
+    def comet(self) -> Call[ChecksumAddress]:
+        return self._view(
+            "COMET()", output_types=["address"], decoder=Web3.to_checksum_address
+        )
+
+
+class CompoundV3Reader(ContractWrapper):
+    """Reader for Compound V3 (Comet) on-chain state."""
+
+    def balance_of(self, account: ChecksumAddress) -> Call[Amount]:
+        return self._view(
+            "balanceOf(address)", account, output_types=["uint256"], decoder=Amount
+        )
+
+    def borrow_balance_of(self, account: ChecksumAddress) -> Call[Amount]:
+        return self._view(
+            "borrowBalanceOf(address)",
+            account,
+            output_types=["uint256"],
+            decoder=Amount,
+        )
+
+    def collateral_balance_of(
+        self, account: ChecksumAddress, asset: ChecksumAddress
+    ) -> Call[Amount]:
+        return self._view(
+            "collateralBalanceOf(address,address)",
+            account,
+            asset,
+            output_types=["uint128"],
+            decoder=Amount,
+        )
+
+    def base_scale(self) -> Call[int]:
+        return self._view("baseScale()", output_types=["uint256"])
+
+    def base_token_price_feed(self) -> Call[ChecksumAddress]:
+        return self._view(
+            "baseTokenPriceFeed()",
+            output_types=["address"],
+            decoder=Web3.to_checksum_address,
+        )
+
+    def get_price(self, price_feed: ChecksumAddress) -> Call[int]:
+        return self._view("getPrice(address)", price_feed, output_types=["uint256"])
+
+    def num_assets(self) -> Call[int]:
+        return self._view("numAssets()", output_types=["uint8"])
+
+    def get_asset_info(self, index: int) -> Call[CometAssetInfo]:
+        return self._view(
+            "getAssetInfo(uint8)",
+            index,
+            output_types=[
+                "(uint8,address,address,uint64,uint64,uint64,uint64,uint128)"
+            ],
+            decoder=_asset_info_decoder,
+        )
+
+    def read_account_value(
+        self, ctx: Web3Context, account: ChecksumAddress
+    ) -> CometAccountValue:
+        """Value ``account``'s collateral and debt as the Comet does, over every
+        collateral it lists rather than the vault's substrates: a revoked substrate
+        does not take collateral out of the account. Only the feeds of held assets
+        are read, as `isLiquidatable` does, so a broken feed of an asset the account
+        does not hold cannot hide its position (four batches)."""
+        multicall = Multicall3(ctx)
+        batch = multicall.batch()
+        count = batch.add(self.num_assets())
+        base_scale = batch.add(self.base_scale())
+        base_feed = batch.add(self.base_token_price_feed())
+        debt = batch.add(self.borrow_balance_of(account))
+        batch.run()
+
+        infos = multicall.aggregate(
+            [self.get_asset_info(i) for i in range(count.value)]
+        )
+        balances = multicall.aggregate(
+            [self.collateral_balance_of(account, info.asset) for info in infos]
+        )
+        held = [
+            (info, balance)
+            for info, balance in zip(infos, balances, strict=True)
+            if balance > 0
+        ]
+
+        batch = multicall.batch()
+        base_price = batch.add(self.get_price(base_feed.value))
+        prices = [batch.add(self.get_price(info.price_feed)) for info, _ in held]
+        batch.run()
+
+        collateral = 0
+        liquidation_limit = 0
+        for (info, balance), price in zip(held, prices, strict=True):
+            value = balance * price.value // info.scale
+            collateral += value
+            liquidation_limit += (
+                value * info.liquidate_collateral_factor // COMET_FACTOR_SCALE
+            )
+        return CometAccountValue(
+            collateral=collateral,
+            liquidation_limit=liquidation_limit,
+            debt=debt.value * base_price.value // base_scale.value,
+        )

{ipor_fusion-4.2.0.dev11 → ipor_fusion-4.2.0.dev14}/src/ipor_fusion/readers/lending_health.py

@@ -1,4 +1,5 @@
-"""Lending health computation for Morpho Blue, Aave V3, Aave V4 and Euler V2 markets.
+"""Lending health computation for Morpho Blue, Aave V3, Aave V4, Euler V2 and
+Compound V3 markets.
 
 Provides a unified view of LTV, liquidation thresholds, and health factors
 for lending positions held by Plasma Vaults.
@@ -7,8 +8,10 @@ for lending positions held by Plasma Vaults.
 from __future__ import annotations
 
 import logging
+from collections.abc import Callable
 from concurrent.futures import ThreadPoolExecutor
 from dataclasses import dataclass, field
+from functools import partial
 
 import requests
 from eth_abi import decode
@@ -30,6 +33,7 @@ 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
+from ipor_fusion.readers.compound_v3 import COMET_PRICE_SCALE, CompoundV3Reader
 from ipor_fusion.readers.euler_v2 import (
     EULER_USD_UNIT_OF_ACCOUNT,
     EulerV2Substrate,
@@ -123,6 +127,18 @@ EULER_V2_MARKET_IDS = frozenset(
     }
 )
 
+# Market IDs served by the Compound V3 fuses. One Comet per market, read from its
+# balance fuse. Health is account-level; a Comet account owing nothing has no
+# liquidation risk and no row. The WETH Comet prices in ETH, not USD.
+COMPOUND_V3_MARKET_IDS = frozenset(
+    {
+        IporFusionMarkets.COMPOUND_V3_USDC,
+        IporFusionMarkets.COMPOUND_V3_USDT,
+        IporFusionMarkets.COMPOUND_V3_WETH,
+        IporFusionMarkets.COMPOUND_V3_INSTITUTIONAL_USDC,
+    }
+)
+
 # Markets whose fuses can borrow but whose health has no reader yet. Their
 # positions are listed as unreadable rather than left out: an unknown
 # liquidation risk is not a healthy one. Dolomite counts only when a
@@ -132,7 +148,6 @@ UNSUPPORTED_BORROW_MARKET_IDS = frozenset(
         IporFusionMarkets.MOONWELL,
         IporFusionMarkets.SILO_V2,
         IporFusionMarkets.EBISU,
-        IporFusionMarkets.COMPOUND_V3_INSTITUTIONAL_USDC,
     }
 )
 _UNSUPPORTED_REASON = "no lending health reader for this market"
@@ -147,6 +162,7 @@ class LendingMarketHealth:
     - Aave V3: None — Aave health is account-level, aggregated across reserves.
     - Aave V4: the Spoke address — account-level per Spoke, across its reserves.
     - Euler V2: the sub-account address — account-level, across its collaterals.
+    - Compound V3: None — account-level on the market's Comet, across its collaterals.
     """
 
     protocol: str
@@ -438,6 +454,57 @@ def _compute_aave_v4_market_health(
     )
 
 
+def _compute_compound_v3_market_health(
+    ctx: Web3Context,
+    comet: ChecksumAddress,
+    vault_address: PlasmaVaultAddress,
+    ipor_market_id: MarketId,
+    market_name: str,
+) -> LendingMarketHealth | UnreadableLendingMarket | None:
+    """Compute LTV health for the vault's account on one Comet; None when it owes
+    nothing. The health factor is the liquidation limit over the debt, so it falls
+    to 1 where `Comet.isLiquidatable` turns true."""
+    try:
+        reader = CompoundV3Reader(comet)
+        if reader.borrow_balance_of(vault_address).call(ctx) == 0:
+            return None
+        account = reader.read_account_value(ctx, vault_address)
+    except _READ_ERRORS as exc:
+        return UnreadableLendingMarket(
+            protocol="compound_v3",
+            market_id=ipor_market_id,
+            market_name=market_name,
+            reason=_reason("account value", exc),
+        )
+    # Dust that prices to nothing: the Comet rounds it the same way and cannot
+    # liquidate it.
+    if account.debt == 0:
+        return None
+
+    has_collateral = account.collateral > 0
+    has_limit = account.liquidation_limit > 0
+    current_ltv = account.debt / account.collateral if has_collateral else None
+    max_ltv = account.liquidation_limit / account.collateral if has_collateral else 0.0
+    # With no limit the health factor is 0, a known liquidation risk; only the usage
+    # has no value.
+    ltv_usage = account.debt / account.liquidation_limit * 100 if has_limit else None
+    in_usd = ipor_market_id != IporFusionMarkets.COMPOUND_V3_WETH
+
+    return LendingMarketHealth(
+        protocol="compound_v3",
+        market_id=ipor_market_id,
+        market_name=market_name,
+        current_ltv=round(current_ltv, 6) if current_ltv is not None else None,
+        max_ltv=round(max_ltv, 6),
+        health_factor=round(account.liquidation_limit / account.debt, 4),
+        total_collateral_usd=(
+            round(account.collateral / COMET_PRICE_SCALE, 2) if in_usd else None
+        ),
+        total_debt_usd=round(account.debt / COMET_PRICE_SCALE, 2) if in_usd else None,
+        ltv_usage_percent=round(ltv_usage, 2) if ltv_usage is not None else None,
+    )
+
+
 @dataclass(frozen=True, slots=True)
 class _EulerV2Account:
     """An EVC sub-account of the vault and the Euler vaults it may borrow from."""
@@ -575,6 +642,7 @@ class _LendingMarkets:
     aave_v3: list[tuple[MarketId, str, ChecksumAddress]]
     aave_v4: list[tuple[MarketId, str, ChecksumAddress]]
     euler_v2: list[tuple[MarketId, str, _EulerV2Account]]
+    compound_v3: list[tuple[MarketId, str, ChecksumAddress]]
     unreadable: list[UnreadableLendingMarket]
 
 
@@ -583,12 +651,14 @@ def _collect_lending_markets(
     balance_fuse_market_ids: list[MarketId],
     market_substrates: dict[MarketId, list[bytes]],
     aave_pools: dict[MarketId, ChecksumAddress],
+    comets: dict[MarketId, ChecksumAddress],
 ) -> _LendingMarkets:
     """Pick the positions to read: Morpho substrates, Aave V3 markets with a Pool,
-    the Spokes of Aave V4 markets and the borrowing Euler V2 sub-accounts. A
-    market that may borrow but has no reader is listed as unreadable."""
+    the Spokes of Aave V4 markets, the borrowing Euler V2 sub-accounts and Compound
+    V3 markets with a Comet. A market that may borrow but has no reader is listed
+    as unreadable."""
     markets = _LendingMarkets(
-        morpho=[], aave_v3=[], aave_v4=[], euler_v2=[], unreadable=[]
+        morpho=[], aave_v3=[], aave_v4=[], euler_v2=[], compound_v3=[], unreadable=[]
     )
 
     for mid in balance_fuse_market_ids:
@@ -621,6 +691,18 @@ def _collect_lending_markets(
                 (mid, name, account)
                 for account in _euler_v2_borrow_accounts(substrates, vault)
             )
+        elif mid in COMPOUND_V3_MARKET_IDS:
+            if comet := comets.get(mid):
+                markets.compound_v3.append((mid, name, comet))
+            else:
+                markets.unreadable.append(
+                    UnreadableLendingMarket(
+                        protocol="compound_v3",
+                        market_id=mid,
+                        market_name=name,
+                        reason="the balance fuse names no Comet",
+                    )
+                )
         elif _can_borrow(mid, substrates):
             markets.unreadable.append(
                 UnreadableLendingMarket(
@@ -634,6 +716,45 @@ def _collect_lending_markets(
     return markets
 
 
+def _health_reads(
+    ctx: Web3Context, vault: PlasmaVaultAddress, markets: _LendingMarkets
+) -> list[Callable[[], LendingMarketHealth | UnreadableLendingMarket | None]]:
+    """One read per position; Aave V3 health is account-level per Pool, so each
+    market reads its own."""
+    reads: list[Callable[[], LendingMarketHealth | UnreadableLendingMarket | None]] = []
+    if markets.morpho:
+        morpho_reader = MorphoReader(morpho_blue_address(ctx.chain_id))
+        reads += [
+            partial(
+                _compute_morpho_market_health,
+                ctx,
+                morpho_reader,
+                morpho_mid,
+                vault,
+                mid,
+                name,
+            )
+            for mid, name, morpho_mid in markets.morpho
+        ]
+    reads += [
+        partial(_compute_aave_market_health, ctx, AaveV3Reader(pool), vault, mid, name)
+        for mid, name, pool in markets.aave_v3
+    ]
+    reads += [
+        partial(_compute_aave_v4_market_health, ctx, spoke, vault, mid, name)
+        for mid, name, spoke in markets.aave_v4
+    ]
+    reads += [
+        partial(_compute_euler_v2_account_health, ctx, account, mid, name)
+        for mid, name, account in markets.euler_v2
+    ]
+    reads += [
+        partial(_compute_compound_v3_market_health, ctx, comet, vault, mid, name)
+        for mid, name, comet in markets.compound_v3
+    ]
+    return reads
+
+
 def fetch_vault_lending_health(
     ctx: Web3Context,
     vault: PlasmaVaultAddress,
@@ -641,6 +762,7 @@ def fetch_vault_lending_health(
     balance_fuse_market_ids: list[MarketId],
     market_substrates: dict[MarketId, list[bytes]],
     aave_pools: dict[MarketId, ChecksumAddress] | None = None,
+    comets: dict[MarketId, ChecksumAddress] | None = None,
 ) -> VaultLendingHealth:
     """Fetch lending health for all lending markets in a vault.
 
@@ -656,68 +778,23 @@ def fetch_vault_lending_health(
             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.
+        comets: Map of Compound V3 market_id -> the Comet its balance fuse reads
+            (`CompoundV3FuseReader.comet`). A Compound V3 market without an entry
+            is listed in ``unreadable``.
     """
     if aave_pools is None:
         core_pool = AAVE_V3_POOL.get(ctx.chain_id)
         aave_pools = {IporFusionMarkets.AAVE_V3: core_pool} if core_pool else {}
 
     markets = _collect_lending_markets(
-        vault, balance_fuse_market_ids, market_substrates, aave_pools
+        vault, balance_fuse_market_ids, market_substrates, aave_pools, comets or {}
     )
 
     results: list[LendingMarketHealth] = []
     unreadable = list(markets.unreadable)
 
     with ThreadPoolExecutor() as pool:
-        futures = []
-
-        if markets.morpho:
-            morpho_reader = MorphoReader(morpho_blue_address(ctx.chain_id))
-            for ipor_mid, name, morpho_mid in markets.morpho:
-                futures.append(
-                    pool.submit(
-                        _compute_morpho_market_health,
-                        ctx,
-                        morpho_reader,
-                        morpho_mid,
-                        vault,
-                        ipor_mid,
-                        name,
-                    )
-                )
-
-        # Aave V3 health is account-level per Pool, so each market reads its own.
-        for ipor_mid, name, aave_pool in markets.aave_v3:
-            futures.append(
-                pool.submit(
-                    _compute_aave_market_health,
-                    ctx,
-                    AaveV3Reader(aave_pool),
-                    vault,
-                    ipor_mid,
-                    name,
-                )
-            )
-
-        for ipor_mid, name, spoke in markets.aave_v4:
-            futures.append(
-                pool.submit(
-                    _compute_aave_v4_market_health,
-                    ctx,
-                    spoke,
-                    vault,
-                    ipor_mid,
-                    name,
-                )
-            )
-
-        for ipor_mid, name, account in markets.euler_v2:
-            futures.append(
-                pool.submit(
-                    _compute_euler_v2_account_health, ctx, account, ipor_mid, name
-                )
-            )
-
+        futures = [pool.submit(read) for read in _health_reads(ctx, vault, markets)]
         for fut in futures:
             result = fut.result()
             if result is None:

{ipor_fusion-4.2.0.dev11 → ipor_fusion-4.2.0.dev14}/src/ipor_fusion/validation.py

@@ -691,9 +691,15 @@ def _lending_health_findings(state: VaultState) -> list[Finding]:
         for u in health.unreadable
     ]
     for market in health.markets:
-        if market.ltv_usage_percent is None:
+        # A critical row with no usage (debt against a zero limit) is still critical.
+        if market.ltv_usage_percent is None and not market.is_critical:
             continue
         ltv = f"{market.current_ltv:.4f}" if market.current_ltv is not None else "?"
+        usage = (
+            f"{market.ltv_usage_percent:.1f}%"
+            if market.ltv_usage_percent is not None
+            else "?"
+        )
         health_factor = (
             f", health_factor={market.health_factor:.4f}"
             if market.health_factor is not None
@@ -702,7 +708,7 @@ def _lending_health_findings(state: VaultState) -> list[Finding]:
         line = (
             f"{market.protocol} {market.market_name}: "
             f"LTV {ltv}/{market.max_ltv:.4f} "
-            f"({market.ltv_usage_percent:.1f}% usage){health_factor}"
+            f"({usage} usage){health_factor}"
         )
         if market.is_critical:
             findings.append(

{ipor_fusion-4.2.0.dev11 → ipor_fusion-4.2.0.dev14}/src/ipor_fusion/vault_data.py

@@ -88,6 +88,7 @@ from ipor_fusion.vault_positions import (
     _fetch_aave_pools,
     _fetch_aave_positions,
     _fetch_breakdown_token_prices,
+    _fetch_comets,
     _fetch_morpho_positions,
 )
 from ipor_fusion.vault_reads import (
@@ -508,16 +509,17 @@ class _MarketReads:
     # Only markets with at least one substrate.
     market_substrates: dict[MarketId, list[bytes]]
     aave_pools: dict[MarketId, ChecksumAddress]
+    comets: dict[MarketId, ChecksumAddress]
     market_balances: dict[MarketId, Amount]
     # False when the vault predates getMarketSubstrates (substrates unknown).
     substrates_available: bool = True
 
 
 def _fetch_market_reads(
-    ctx: Web3Context, plasma_vault: PlasmaVault, *, with_aave_pools: bool
+    ctx: Web3Context, plasma_vault: PlasmaVault, *, with_lending_venues: bool
 ) -> _MarketReads:
     """Balance fuses, then every market's dependency graph and substrates in
-    one batch, then (optionally) the Aave V3 Pools behind the markets."""
+    one batch, then (optionally) the Aave V3 Pools and Comets behind the markets."""
     balance_fuses = plasma_vault.read_balance_fuses(ctx)
     market_ids = [bf.market_id for bf in balance_fuses]
     venues = list(dict.fromkeys(market_ids))
@@ -545,7 +547,8 @@ def _fetch_market_reads(
         market_substrates={
             mid: subs for mid, subs in zip(market_ids, substrates, strict=True) if subs
         },
-        aave_pools=_fetch_aave_pools(ctx, balance_fuses) if with_aave_pools else {},
+        aave_pools=_fetch_aave_pools(ctx, balance_fuses) if with_lending_venues else {},
+        comets=_fetch_comets(ctx, balance_fuses) if with_lending_venues else {},
         market_balances={mid: balance.value for mid, balance in balances},
         substrates_available=None not in substrates,
     )
@@ -583,6 +586,7 @@ def _fetch_lending_reads(
             balance_fuse_market_ids=[bf.market_id for bf in markets.balance_fuses],
             market_substrates=markets.market_substrates,
             aave_pools=markets.aave_pools,
+            comets=markets.comets,
         ),
     )
     morpho_unread: list[str] = []
@@ -668,7 +672,7 @@ def fetch_vault_data(
             _safe_call, partial(plasma_vault.read_stored_markets_total, ctx)
         )
         f_markets = pool.submit(
-            _fetch_market_reads, ctx, plasma_vault, with_aave_pools=lending
+            _fetch_market_reads, ctx, plasma_vault, with_lending_venues=lending
         )
 
         markets = f_markets.result()

{ipor_fusion-4.2.0.dev11 → ipor_fusion-4.2.0.dev14}/src/ipor_fusion/vault_positions.py

@@ -20,7 +20,12 @@ from ipor_fusion.readers.aave_v3 import (
     AaveV3PositionBreakdown,
     AaveV3Reader,
 )
-from ipor_fusion.readers.lending_health import AAVE_V3_MARKET_IDS, MORPHO_MARKET_IDS
+from ipor_fusion.readers.compound_v3 import CompoundV3FuseReader
+from ipor_fusion.readers.lending_health import (
+    AAVE_V3_MARKET_IDS,
+    COMPOUND_V3_MARKET_IDS,
+    MORPHO_MARKET_IDS,
+)
 from ipor_fusion.readers.morpho import (
     MorphoPositionBreakdown,
     MorphoReader,
@@ -152,6 +157,28 @@ def _fetch_aave_pools(
     }
 
 
+def _fetch_comets(
+    ctx: Web3Context, balance_fuses: list[BalanceFuse]
+) -> dict[MarketId, ChecksumAddress]:
+    """Map every Compound V3 market to the Comet its balance fuse reads. A balance
+    fuse that names no Comet reverts or answers with empty data and is left out."""
+    fuses = {
+        bf.market_id: bf.fuse
+        for bf in balance_fuses
+        if bf.market_id in COMPOUND_V3_MARKET_IDS
+    }
+    if not fuses:
+        return {}
+    comets = Multicall3(ctx).try_aggregate(
+        [CompoundV3FuseReader(fuse).comet() for fuse in fuses.values()]
+    )
+    return {
+        mid: comet
+        for mid, comet in zip(fuses, comets, strict=True)
+        if comet is not None
+    }
+
+
 def _fetch_aave_positions(
     ctx: Web3Context,
     pool: ThreadPoolExecutor,