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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: ipor-fusion
-Version: 4.2.0.dev9
+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
@@ -520,7 +520,7 @@ Fuse.method()  -->  FuseAction  -->  PlasmaVault.execute([actions])  -->  Call
 | Euler V2 | `EulerV2SupplyFuse`, `EulerV2CollateralFuse`, `EulerV2ControllerFuse`, `EulerV2BorrowFuse`, `EulerV2BatchFuse`, `EulerV2SwapDeployFuse`, `EulerV2SwapReconfigureFuse`, `EulerV2SwapRegistryFuse` |
 | Uniswap V3 | `UniswapV3SwapFuse`, `UniswapV3NewPositionFuse`, `UniswapV3ModifyPositionFuse`, `UniswapV3CollectFuse` |
 | Ramses V2 | `RamsesV2NewPositionFuse`, `RamsesV2ModifyPositionFuse`, `RamsesV2CollectFuse`, `RamsesClaimFuse` |
-| Compound V3 | `CompoundV3SupplyFuse` |
+| Compound V3 | `CompoundV3SupplyFuse`, `CompoundV3BorrowFuse`, `CompoundV3ClaimFuse` |
 | Gearbox V3 | `GearboxSupplyFuse`, `GearboxStakeFuse` |
 | ERC-4626 | `ERC4626SupplyFuse` |
 | Fluid Instadapp | `FluidInstadappSupplyFuse`, `FluidInstadappStakingFuse` |
@@ -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.dev9 → ipor_fusion-4.2.0.dev14}/README.md

@@ -471,7 +471,7 @@ Fuse.method()  -->  FuseAction  -->  PlasmaVault.execute([actions])  -->  Call
 | Euler V2 | `EulerV2SupplyFuse`, `EulerV2CollateralFuse`, `EulerV2ControllerFuse`, `EulerV2BorrowFuse`, `EulerV2BatchFuse`, `EulerV2SwapDeployFuse`, `EulerV2SwapReconfigureFuse`, `EulerV2SwapRegistryFuse` |
 | Uniswap V3 | `UniswapV3SwapFuse`, `UniswapV3NewPositionFuse`, `UniswapV3ModifyPositionFuse`, `UniswapV3CollectFuse` |
 | Ramses V2 | `RamsesV2NewPositionFuse`, `RamsesV2ModifyPositionFuse`, `RamsesV2CollectFuse`, `RamsesClaimFuse` |
-| Compound V3 | `CompoundV3SupplyFuse` |
+| Compound V3 | `CompoundV3SupplyFuse`, `CompoundV3BorrowFuse`, `CompoundV3ClaimFuse` |
 | Gearbox V3 | `GearboxSupplyFuse`, `GearboxStakeFuse` |
 | ERC-4626 | `ERC4626SupplyFuse` |
 | Fluid Instadapp | `FluidInstadappSupplyFuse`, `FluidInstadappStakingFuse` |
@@ -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.dev9 → ipor_fusion-4.2.0.dev14}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "ipor-fusion"
-version = "4.2.0.dev9"
+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.dev9 → ipor_fusion-4.2.0.dev14}/src/ipor_fusion/__init__.py

@@ -171,6 +171,8 @@ from ipor_fusion.fuses import (
     AaveV3SupplyFuse,
     AsyncActionFuse,
     AsyncActionSubstrates,
+    CompoundV3BorrowFuse,
+    CompoundV3ClaimFuse,
     CompoundV3SupplyFuse,
     ERC4626SupplyFuse,
     EulerSwapDynamicParams,
@@ -310,6 +312,9 @@ from ipor_fusion.readers import (
     AaveV4OracleReader,
     AaveV4SpokeReader,
     AaveV4UserAccountData,
+    CometAccountValue,
+    CometAssetInfo,
+    CompoundV3FuseReader,
     CompoundV3Reader,
     LendingMarketHealth,
     MiddlewarePricedToken,
@@ -656,6 +661,8 @@ __all__ = [
     "UniswapV3NewPositionEvent",
     "UniswapV3ClosePositionEvent",
     "UniswapV3Events",
+    "CompoundV3BorrowFuse",
+    "CompoundV3ClaimFuse",
     "CompoundV3SupplyFuse",
     "RamsesV2NewPositionFuse",
     "RamsesV2ModifyPositionFuse",
@@ -784,6 +791,9 @@ __all__ = [
     "AaveV4OracleReader",
     "AaveV4SpokeReader",
     "AaveV4UserAccountData",
+    "CometAccountValue",
+    "CometAssetInfo",
+    "CompoundV3FuseReader",
     "CompoundV3Reader",
     "HYPEREVM_CHAIN_ID",
     "LendingMarketHealth",

{ipor_fusion-4.2.0.dev9 → 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.dev9 → ipor_fusion-4.2.0.dev14}/src/ipor_fusion/fuses/__init__.py

@@ -1,7 +1,11 @@
 from ipor_fusion.fuses.aave_v3 import AaveV3BorrowFuse, AaveV3SupplyFuse
 from ipor_fusion.fuses.async_action import AsyncActionFuse, AsyncActionSubstrates
 from ipor_fusion.fuses.base import Fuse, FuseAction, StakeFuse
-from ipor_fusion.fuses.compound_v3 import CompoundV3SupplyFuse
+from ipor_fusion.fuses.compound_v3 import (
+    CompoundV3BorrowFuse,
+    CompoundV3ClaimFuse,
+    CompoundV3SupplyFuse,
+)
 from ipor_fusion.fuses.erc4626 import ERC4626SupplyFuse
 from ipor_fusion.fuses.euler_v2 import (
     EulerSwapDynamicParams,
@@ -112,6 +116,8 @@ __all__ = [
     "UniswapV3NewPositionEvent",
     "UniswapV3ClosePositionEvent",
     "UniswapV3Events",
+    "CompoundV3BorrowFuse",
+    "CompoundV3ClaimFuse",
     "CompoundV3SupplyFuse",
     "RamsesV2NewPositionFuse",
     "RamsesV2ModifyPositionFuse",

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

@@ -0,0 +1,62 @@
+from eth_typing import ChecksumAddress
+
+from ipor_fusion.fuses.base import Fuse, FuseAction
+from ipor_fusion.types import Amount
+
+
+class CompoundV3SupplyFuse(Fuse):
+    """Fuse for supplying and withdrawing assets on Compound V3."""
+
+    SIGNATURES = (
+        "enter((address,uint256))",
+        "exit((address,uint256))",
+    )
+
+    def supply(self, *, asset: ChecksumAddress, amount: Amount) -> FuseAction:
+        self._validate_address(asset, "asset")
+        self._validate_amount(amount, "amount")
+        return self._action_raw("enter((address,uint256))", [[asset, amount]])
+
+    def withdraw(self, *, asset: ChecksumAddress, amount: Amount) -> FuseAction:
+        self._validate_address(asset, "asset")
+        self._validate_amount(amount, "amount")
+        return self._action_raw("exit((address,uint256))", [[asset, amount]])
+
+
+class CompoundV3BorrowFuse(Fuse):
+    """Fuse for borrowing and repaying the base token of a Comet.
+
+    The fuse is bound to one Comet, whose base token is the only asset it can
+    borrow, so neither action names an asset; the base token must be granted as
+    a substrate of the fuse's market. A repay is capped at the debt, so
+    ``MAX_UINT256`` repays in full.
+    """
+
+    SIGNATURES = (
+        "enter((uint256))",
+        "exit((uint256))",
+    )
+
+    def borrow(self, *, amount: Amount) -> FuseAction:
+        self._validate_amount(amount, "amount")
+        return self._action_raw("enter((uint256))", [[amount]])
+
+    def repay(self, *, amount: Amount) -> FuseAction:
+        self._validate_amount(amount, "amount")
+        return self._action_raw("exit((uint256))", [[amount]])
+
+
+class CompoundV3ClaimFuse(Fuse):
+    """Fuse for claiming a Comet's rewards to the vault's rewards claim manager.
+
+    The fuse is bound to one ``CometRewards``. Route the action through
+    ``RewardsManager.claim_rewards(...)``, not ``PlasmaVault.execute(...)``, and
+    register the fuse with ``RewardsManager.add_reward_fuses(...)`` first. A
+    Comet with no reward token configured reverts ``NotSupported(address)``.
+    """
+
+    SIGNATURES = ("claim(address)",)
+
+    def claim(self, *, comet: ChecksumAddress) -> FuseAction:
+        self._validate_address(comet, "comet")
+        return self._action_raw("claim(address)", [comet])

{ipor_fusion-4.2.0.dev9 → ipor_fusion-4.2.0.dev14}/src/ipor_fusion/market_ids.py

@@ -106,6 +106,10 @@ class IporFusionMarkets:
     # Substrate type: HyperCoreSubstrateLib (1 SpotToken, 2 PerpMarket,
     # 3 Destination, 4 Builder, 5 Config, 6 SendCap, 7 PerpPositionCap).
     HYPERCORE = MarketId(55)
+    # Compound V3 Institutional USDC (ciUSDCv3) on Ethereum: its own Comet, so
+    # the Compound V3 fuses are deployed again under this id; substrates: asset
+    # addresses, as for COMPOUND_V3_USDC
+    COMPOUND_V3_INSTITUTIONAL_USDC = MarketId(57)
     # POL unstaking via sPOLController. The out-of-band id is baked into the
     # deployed fuses as an immutable (424243 = 0x67933), so it must match the
     # deployments. Substrates per IporFusionMarkets.sol: the sPOLController

{ipor_fusion-4.2.0.dev9 → 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.dev9 → 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
@@ -146,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
@@ -437,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."""
@@ -574,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]
 
 
@@ -582,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:
@@ -620,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(
@@ -633,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,
@@ -640,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.
 
@@ -655,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: