ipor-fusion 4.1.0.dev50__tar.gz → 4.1.0.dev54__tar.gz

{ipor_fusion-4.1.0.dev50 → ipor_fusion-4.1.0.dev54}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: ipor-fusion
-Version: 4.1.0.dev50
+Version: 4.1.0.dev54
 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.1.0.dev50 → ipor_fusion-4.1.0.dev54}/pyproject.toml

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

{ipor_fusion-4.1.0.dev50 → ipor_fusion-4.1.0.dev54}/src/ipor_fusion/__init__.py

@@ -325,6 +325,7 @@ from ipor_fusion.readers.oracle_mapping_nodes import (
     Erc4626DetailJson,
     MiddlewareFallbackDetailJson,
     MorphoFeedDetailJson,
+    MorphoOracleFeedJson,
     OracleAssetJson,
     OracleMappingJson,
     OracleNodeJson,
@@ -760,6 +761,7 @@ __all__ = [
     "Erc4626DetailJson",
     "MiddlewareFallbackDetailJson",
     "MorphoFeedDetailJson",
+    "MorphoOracleFeedJson",
     "OracleAssetJson",
     "OracleMappingJson",
     "OracleNodeJson",

{ipor_fusion-4.1.0.dev50 → ipor_fusion-4.1.0.dev54}/src/ipor_fusion/cli/vault_health.py

@@ -12,6 +12,7 @@ from ipor_fusion.validation import (
     VaultValidation,
 )
 from ipor_fusion.vault_data import VaultData
+from ipor_fusion.vault_erc20 import ERC20_CACHE_TOLERANCE
 from ipor_fusion.vault_info import health_check_lists
 
 
@@ -146,7 +147,11 @@ def _print_erc20_cache_divergence(
             f"ERC20 direct={direct_fmt} — likely stale cache",
             fg="yellow",
         )
-    elif cached > 0 and direct > 0 and abs(cached - direct) / direct > 0.1:
+    elif (
+        cached > 0
+        and direct > 0
+        and abs(cached - direct) / direct > ERC20_CACHE_TOLERANCE
+    ):
         click.secho(
             f"  ERC20_VAULT_BALANCE cached={cached_fmt}, "
             f"ERC20 direct={direct_fmt} — significant divergence",

{ipor_fusion-4.1.0.dev50 → ipor_fusion-4.1.0.dev54}/src/ipor_fusion/mcp/models.py

@@ -564,11 +564,21 @@ class Erc4626Detail(_Base):
     rate: str | None
 
 
+class MorphoOracleFeed(AggregatorFeedDetail):
+    """A feed behind a Morpho oracle; role names the getter it came from."""
+
+    role: str
+
+
 class MorphoFeedDetail(_Base):
     morpho_oracle: str
     collateral_token: str | None
     loan_token: str
     morpho_price: str | None
+    oracle_feeds: list[MorphoOracleFeed] | None = Field(
+        description="Feeds the oracle uses; null when it does not expose them, "
+        "so their freshness cannot be read."
+    )
 
 
 class MiddlewareFallbackDetail(_Base):

{ipor_fusion-4.1.0.dev50 → ipor_fusion-4.1.0.dev54}/src/ipor_fusion/mcp/server.py

@@ -468,7 +468,9 @@ def vault_oracle_mapping(
     description, a foreign getter answering; still resolved, but verify the
     address yourself if identity matters), ERC4626PriceFeed (share→asset
     rate, recurses on the underlying), CollateralTokenOnMorphoMarketPriceFeed
-    (recurses on the loan token), middleware_fallback (no per-vault source;
+    (recurses on the loan token; source_detail.oracle_feeds lists the feeds
+    behind the Morpho oracle, null when it does not expose them),
+    middleware_fallback (no per-vault source;
     priced by the oracle's underlying global middleware, followed as a
     dependency when discoverable), custom_unknown (partial). Classification is
     heuristic interface probing: it grades on-chain evidence and cannot prove

{ipor_fusion-4.1.0.dev50 → ipor_fusion-4.1.0.dev54}/src/ipor_fusion/readers/__init__.py

@@ -45,6 +45,7 @@ from ipor_fusion.readers.oracle_mapping_nodes import (
     Erc4626DetailJson,
     MiddlewareFallbackDetailJson,
     MorphoFeedDetailJson,
+    MorphoOracleFeedJson,
     OracleAssetJson,
     OracleMappingJson,
     OracleNodeJson,
@@ -94,6 +95,7 @@ __all__ = [
     "Erc4626DetailJson",
     "MiddlewareFallbackDetailJson",
     "MorphoFeedDetailJson",
+    "MorphoOracleFeedJson",
     "OracleAssetJson",
     "OracleMappingJson",
     "OracleNodeJson",

{ipor_fusion-4.1.0.dev50 → ipor_fusion-4.1.0.dev54}/src/ipor_fusion/readers/oracle_mapping.py

@@ -9,7 +9,8 @@ collateral feeds). Unknown feeds are reported as partial, never dropped.
 A zero source is not a dead end: the oracle may be a manager variant that
 delegates such assets to an underlying global middleware — that delegation is
 followed and reported as ``middleware_fallback``. Every aggregator-compatible
-read (Chainlink-tier leaves, dual-cross-reference component feeds) carries
+read (Chainlink-tier leaves, dual-cross-reference component feeds, feeds
+behind a Morpho oracle) carries
 ``description()`` and the full ``latestRoundData()`` round in
 ``source_detail`` — raw values plus ISO-8601 UTC twins of the timestamps,
 no staleness judgment; ``description`` is null when the feed does not
@@ -83,6 +84,7 @@ from ipor_fusion.readers.oracle_mapping_nodes import (
     _apply_dependency_status,
     _collect_unresolved,
     _mapping_status,
+    _morpho_oracle_feeds,
     _partial,
     _price_block,
     _resolve_chainlink,
@@ -181,6 +183,7 @@ def _resolve_morpho(
         "collateral_token": collateral,
         "loan_token": loan,
         "morpho_price": str(price) if price is not None else None,
+        "oracle_feeds": _morpho_oracle_feeds(reader, morpho_oracle),
     }
     dep = _resolve(reader, loan, depth + 1, visited, max_depth)
     node.dependencies = [dep]

{ipor_fusion-4.1.0.dev50 → ipor_fusion-4.1.0.dev54}/src/ipor_fusion/readers/oracle_mapping_nodes.py

@@ -30,6 +30,12 @@ TYPE_CHAINLINK = "ChainlinkAggregator"
 TYPE_CHAINLINK_STYLE = "chainlink_style"
 TYPE_ERC4626 = "ERC4626PriceFeed"
 TYPE_MORPHO = "CollateralTokenOnMorphoMarketPriceFeed"
+MORPHO_ORACLE_FEED_ROLES = (
+    "BASE_FEED_1",
+    "BASE_FEED_2",
+    "QUOTE_FEED_1",
+    "QUOTE_FEED_2",
+)
 TYPE_DUAL_XREF = "DualCrossReferencePriceFeed"
 TYPE_MIDDLEWARE_FALLBACK = "middleware_fallback"
 TYPE_UNKNOWN = "custom_unknown"
@@ -83,11 +89,21 @@ class Erc4626DetailJson(TypedDict):
     rate: str | None
 
 
+class MorphoOracleFeedJson(AggregatorFeedDetailJson):
+    """A feed behind a Morpho oracle; ``role`` names the getter it came from."""
+
+    role: str
+
+
 class MorphoFeedDetailJson(TypedDict):
+    """``oracle_feeds`` lists the feeds the oracle uses; null when the oracle
+    does not expose them, so their freshness cannot be read."""
+
     morpho_oracle: ChecksumAddress
     collateral_token: ChecksumAddress | None
     loan_token: ChecksumAddress
     morpho_price: str | None
+    oracle_feeds: list[MorphoOracleFeedJson] | None
 
 
 class MiddlewareFallbackDetailJson(TypedDict):
@@ -413,6 +429,31 @@ def _resolve_chainlink(
     return node
 
 
+def _morpho_oracle_feeds(
+    reader: OracleMappingReader, morpho_oracle: ChecksumAddress
+) -> list[MorphoOracleFeedJson] | None:
+    """The feeds behind a Morpho oracle, skipping its unused (zero) slots."""
+    feeds: list[MorphoOracleFeedJson] = []
+    for role in MORPHO_ORACLE_FEED_ROLES:
+        address = reader.morpho_oracle_feed(morpho_oracle, role)
+        if address is None:
+            return None
+        if address.lower() == ZERO_ADDRESS:
+            continue
+        feeds.append(
+            {
+                "address": address,
+                **_aggregator_detail(
+                    reader.feed_description(address),
+                    reader.feed_latest_round_data(address),
+                    reader.feed_decimals(address),
+                ),
+                "role": role,
+            }
+        )
+    return feeds
+
+
 def _resolve_dual_xref(
     reader: OracleMappingReader,
     node: OracleNode,

{ipor_fusion-4.1.0.dev50 → ipor_fusion-4.1.0.dev54}/src/ipor_fusion/readers/oracle_mapping_reader.py

@@ -59,6 +59,9 @@ class _MorphoOracle(ContractWrapper):
     def price(self) -> Call[int]:
         return self._view("price()", output_types=["uint256"], decoder=int)
 
+    def feed(self, role: str) -> Call[ChecksumAddress]:
+        return self._view(f"{role}()", output_types=["address"], decoder=_addr)
+
 
 class _DualXrefFeed(ContractWrapper):
     def asset_x(self) -> Call[ChecksumAddress]:
@@ -222,6 +225,11 @@ class OracleMappingReader:
     def morpho_oracle_price(self, morpho_oracle: ChecksumAddress) -> int | None:
         return self._safe(_MorphoOracle(morpho_oracle).price())
 
+    def morpho_oracle_feed(
+        self, morpho_oracle: ChecksumAddress, role: str
+    ) -> ChecksumAddress | None:
+        return self._safe(_MorphoOracle(morpho_oracle).feed(role))
+
     def feed_asset_x(self, source: ChecksumAddress) -> ChecksumAddress | None:
         return self._safe(_DualXrefFeed(source).asset_x())
 

{ipor_fusion-4.1.0.dev50 → ipor_fusion-4.1.0.dev54}/src/ipor_fusion/validation.py

@@ -43,6 +43,10 @@ from ipor_fusion.vault_data import (
     GET_TOTAL_SUPPLY_CAP,
     fetch_vault_data,
 )
+from ipor_fusion.vault_erc20 import (
+    ERC20_CACHE_TOLERANCE,
+    cache_lags_value,
+)
 from ipor_fusion.vault_erc20 import Erc20Holding as Erc20Holding
 from ipor_fusion.vault_erc20 import Erc20Holdings as Erc20Holdings
 
@@ -704,7 +708,8 @@ def _erc20_findings(state: VaultState, erc20: Erc20Holdings) -> list[Finding]:
     non_underlying = erc20.value_in_asset - underlying
     cached = erc20.market_cached_value
     if non_underlying > 0 and (
-        cached == 0 or abs(non_underlying - cached) / non_underlying > 0.1
+        cached == 0
+        or abs(non_underlying - cached) / non_underlying > ERC20_CACHE_TOLERANCE
     ):
         findings.append(
             Finding(
@@ -747,7 +752,7 @@ def _uncovered_erc20_lines(state: VaultState, erc20: Erc20Holdings) -> list[str]
         )
         if address not in covered:
             lines.append(f"{row} — not in any balance fuse substrate")
-        elif 0 < cached_usd < (token.usd_value or 0):
+        elif cached_usd > 0 and cache_lags_value(token.usd_value or 0, cached_usd):
             lines.append(
                 f"{row} — {usd.strip()} not reflected in totalAssets (stale cache)"
             )

{ipor_fusion-4.1.0.dev50 → ipor_fusion-4.1.0.dev54}/src/ipor_fusion/vault_erc20.py

@@ -19,6 +19,16 @@ from ipor_fusion.market_ids import IporFusionMarkets
 from ipor_fusion.substrates import decode_substrate
 from ipor_fusion.types import Amount, Decimals, MarketId, PlasmaVaultAddress, Price
 
+# The cached value is written at an earlier price and the live one is rounded,
+# so the two never match exactly; a gap within this share of the live value is
+# not staleness.
+ERC20_CACHE_TOLERANCE = 0.1
+
+
+def cache_lags_value(usd_value: float, cached_usd: float) -> bool:
+    """Whether a live USD value exceeds the market's cached value beyond tolerance."""
+    return usd_value - cached_usd > ERC20_CACHE_TOLERANCE * usd_value
+
 
 @dataclass(frozen=True)
 class Erc20Holding:
@@ -216,7 +226,7 @@ def _holding(
     elif (
         read.price_usd
         and cached_usd is not None
-        and amount * read.price_usd > cached_usd
+        and cache_lags_value(amount * read.price_usd, cached_usd)
     ):
         note = (
             f"${amount * read.price_usd:,.2f} not reflected in totalAssets "

{ipor_fusion-4.1.0.dev50 → ipor_fusion-4.1.0.dev54}/tests/_oracle_mapping_fake.py

@@ -52,6 +52,7 @@ class FakeReader:
         self.feeds: dict[str, Feed] = {}
         self.vaults: dict[str, Erc4626] = {}
         self.morpho_prices: dict[str, int] = {}
+        self.morpho_feeds: dict[str, dict[str, str]] = {}
         # oracle variant (middleware-fallback resolution); "_mw" because the
         # exact method name would be shadowed by the attribute
         self.underlying_mw: str | None = None
@@ -125,6 +126,9 @@ class FakeReader:
     def morpho_oracle_price(self, o: str) -> int | None:
         return self.morpho_prices.get(o)
 
+    def morpho_oracle_feed(self, o: str, role: str) -> str | None:
+        return self.morpho_feeds.get(o, {}).get(role)
+
     def feed_asset_x(self, s: str) -> str | None:
         return self._f(s).get("asset_x")
 

{ipor_fusion-4.1.0.dev50 → ipor_fusion-4.1.0.dev54}/tests/fixtures/oracle_mapping_golden/mapping.json

@@ -300,7 +300,22 @@
         "morpho_oracle": "0x0000000000000000000000000000000000000031",
         "collateral_token": "0x0000000000000000000000000000000000000006",
         "loan_token": "0x0000000000000000000000000000000000000001",
-        "morpho_price": "970000000000000000000000"
+        "morpho_price": "970000000000000000000000",
+        "oracle_feeds": [
+          {
+            "address": "0x0000000000000000000000000000000000000032",
+            "description": "COLL / LOAN",
+            "round_id": "9",
+            "answer": "970000000000000000",
+            "decimals": 18,
+            "started_at": 1700000000,
+            "started_at_utc": "2023-11-14T22:13:20Z",
+            "updated_at": 1700000050,
+            "updated_at_utc": "2023-11-14T22:14:10Z",
+            "answered_in_round": "9",
+            "role": "BASE_FEED_1"
+          }
+        ]
       },
       "dependencies": [
         {

{ipor_fusion-4.1.0.dev50 → ipor_fusion-4.1.0.dev54}/tests/fixtures/oracle_mapping_golden/mapping.mcp.json

@@ -300,7 +300,22 @@
         "morpho_oracle": "0x0000000000000000000000000000000000000031",
         "collateral_token": "0x0000000000000000000000000000000000000006",
         "loan_token": "0x0000000000000000000000000000000000000001",
-        "morpho_price": "970000000000000000000000"
+        "morpho_price": "970000000000000000000000",
+        "oracle_feeds": [
+          {
+            "address": "0x0000000000000000000000000000000000000032",
+            "description": "COLL / LOAN",
+            "round_id": "9",
+            "answer": "970000000000000000",
+            "decimals": 18,
+            "started_at": 1700000000,
+            "started_at_utc": "2023-11-14T22:13:20Z",
+            "updated_at": 1700000050,
+            "updated_at_utc": "2023-11-14T22:14:10Z",
+            "answered_in_round": "9",
+            "role": "BASE_FEED_1"
+          }
+        ]
       },
       "dependencies": [
         {

{ipor_fusion-4.1.0.dev50 → ipor_fusion-4.1.0.dev54}/tests/test_cli_oracle_mapping_golden.py

@@ -154,6 +154,17 @@ def _reader() -> FakeReader:
         "loan": USDC,
     }
     r.morpho_prices[addr(0x31)] = 970_000 * 10**18
+    r.morpho_feeds[addr(0x31)] = {
+        "BASE_FEED_1": addr(0x32),
+        "BASE_FEED_2": addr(0),
+        "QUOTE_FEED_1": addr(0),
+        "QUOTE_FEED_2": addr(0),
+    }
+    r.feeds[addr(0x32)] = {
+        "round": (9, 97 * 10**16, 1_700_000_000, 1_700_000_050, 9),
+        "feed_decimals": 18,
+        "description": "COLL / LOAN",
+    }
 
     r.symbols[WAT] = "WAT"
     r.decimals[WAT] = 18

{ipor_fusion-4.1.0.dev50 → ipor_fusion-4.1.0.dev54}/tests/test_oracle_mapping.py

@@ -270,6 +270,53 @@ class TestResolve:
         assert [d.asset for d in node.dependencies] == [loan]
         assert node.path[:2] == ["COLL", "Morpho collateral/loan oracle"]
 
+    def test_morpho_oracle_feeds_report_their_rounds_and_skip_unused_slots(self):
+        r = FakeReader()
+        coll, loan = addr(1), addr(2)
+        feed, m_oracle, base_feed = addr(0x11), addr(0x31), addr(0x41)
+        r.sources[coll] = feed
+        r.prices[coll] = Price(asset=coll, amount=10**8, decimals=8)
+        r.feeds[feed] = {"morpho_oracle": m_oracle, "collateral": coll, "loan": loan}
+        r.feeds[base_feed] = {
+            "round": (7, 10**18, 1_700_000_000, 1_700_000_100, 7),
+            "feed_decimals": 18,
+            "description": "COLL / LOAN",
+        }
+        zero = addr(0)
+        r.morpho_feeds[m_oracle] = {
+            "BASE_FEED_1": base_feed,
+            "BASE_FEED_2": zero,
+            "QUOTE_FEED_1": zero,
+            "QUOTE_FEED_2": zero,
+        }
+        chainlink_asset(r, loan, addr(0x12), symbol="LOAN")
+
+        detail = om.resolve_asset(r, coll, max_depth=6).source_detail
+
+        assert detail is not None and "oracle_feeds" in detail
+        feeds = detail["oracle_feeds"]
+        assert feeds is not None
+        assert [(f["role"], f["address"]) for f in feeds] == [
+            ("BASE_FEED_1", base_feed)
+        ]
+        assert feeds[0]["description"] == "COLL / LOAN"
+        assert feeds[0]["updated_at"] == 1_700_000_100
+
+    def test_morpho_oracle_without_the_feed_getters_reports_none(self):
+        r = FakeReader()
+        coll, loan = addr(1), addr(2)
+        feed, m_oracle = addr(0x11), addr(0x31)
+        r.sources[coll] = feed
+        r.prices[coll] = Price(asset=coll, amount=10**8, decimals=8)
+        r.feeds[feed] = {"morpho_oracle": m_oracle, "collateral": coll, "loan": loan}
+        chainlink_asset(r, loan, addr(0x12), symbol="LOAN")
+
+        node = om.resolve_asset(r, coll, max_depth=6)
+
+        assert node.status == "resolved"
+        assert node.source_detail is not None and "oracle_feeds" in node.source_detail
+        assert node.source_detail["oracle_feeds"] is None
+
     def test_dual_xref_wins_over_chainlink(self):
         r = FakeReader()
         wsteth = addr(1)
@@ -1165,6 +1212,7 @@ class TestOracleMappingReader:
         assert reader.feed_asset_x_asset_y_feed(feed) == target
         assert reader.feed_asset_y_usd_feed(feed) == target
         assert reader.feed_aggregator(feed) == target
+        assert reader.morpho_oracle_feed(addr(0x31), "BASE_FEED_1") == target
 
         ctx.call.return_value = encode(["uint256"], [1_030_000])
         assert reader.morpho_oracle_price(addr(0x31)) == 1_030_000

{ipor_fusion-4.1.0.dev50 → ipor_fusion-4.1.0.dev54}/tests/test_public_api.py

@@ -228,6 +228,7 @@ _ALL_SNAPSHOT: dict[str, frozenset[str]] = {
             "MorphoClaimFuse",
             "MorphoCollateralFuse",
             "MorphoFeedDetailJson",
+            "MorphoOracleFeedJson",
             "MorphoFlashLoanFuse",
             "MorphoFlowCapConfigJson",
             "MorphoMarket",
@@ -952,6 +953,7 @@ _ALL_SNAPSHOT: dict[str, frozenset[str]] = {
             "MiddlewarePricedToken",
             "UnpriceableCheck",
             "MorphoFeedDetailJson",
+            "MorphoOracleFeedJson",
             "MorphoMarket",
             "MorphoMarketParams",
             "MorphoMarketRates",

{ipor_fusion-4.1.0.dev50 → ipor_fusion-4.1.0.dev54}/tests/test_validation.py

@@ -40,7 +40,13 @@ from ipor_fusion.market_ids import IporFusionMarkets
 from ipor_fusion.types import ChainId, MarketId
 from ipor_fusion.validation import GET_MARKET_SUBSTRATES, Reconciliation
 from ipor_fusion.vault_data import VaultData, _MarketReads, _VaultReads
-from ipor_fusion.vault_erc20 import _Asset, _erc20_holdings, _read_erc20_market
+from ipor_fusion.vault_erc20 import (
+    _Asset,
+    _erc20_holdings,
+    _Erc20Market,
+    _read_erc20_market,
+    _TokenRead,
+)
 
 
 def _addr(suffix: str) -> str:
@@ -57,6 +63,11 @@ ORPHAN_FUSE = _addr("f5")
 AAVE = IporFusionMarkets.AAVE_V3
 MORPHO = IporFusionMarkets.MORPHO
 ERC20_MARKET = IporFusionMarkets.ERC20_VAULT_BALANCE
+# A token whose value matches the market's cached value but for float rounding.
+ASSET_PRICE = 2594.826591677957
+ROUNDED_BALANCE = 3663278943628990
+ROUNDED_PRICE = 2269.8825
+ROUNDED_CACHE = 3204535051949216
 WAD = 10**18
 
 
@@ -276,6 +287,16 @@ class TestRouting:
         assert heading == "ERC20 holdings not covered by balance fuses:"
         assert [row.split()[0] for row in rows] == ["AAA", "BBB"]
 
+    def test_rounding_gap_to_the_cache_is_not_uncovered(self):
+        state = _erc20_state(asset_price_usd=ASSET_PRICE)
+        erc20 = Erc20Holdings(
+            tokens=(holding(TOKEN, balance=ROUNDED_BALANCE, price_usd=ROUNDED_PRICE),),
+            value_in_asset=ROUNDED_CACHE,
+            market_cached_value=ROUNDED_CACHE,
+        )
+        validation = validate(state, 100 * WAD, erc20)
+        assert "uncovered_erc20" not in [check for check, _ in _checks(validation)]
+
     def test_stale_erc20_cache_and_missing_price_feed(self):
         erc20 = Erc20Holdings(
             value_in_asset=50 * WAD,
@@ -598,6 +619,17 @@ class TestReadErc20Holdings:
         assert erc20.market_cached_value == 2 * WAD
         assert erc20.unpriced_tokens == (f"{OTHER.lower()} (?)",)
 
+    def test_rounding_gap_to_the_cache_keeps_the_token_in_the_market(self):
+        erc20 = _erc20_holdings(
+            _Asset(ASSET, 18, ASSET_PRICE),  # type: ignore[arg-type]
+            _Erc20Market(  # type: ignore[arg-type]
+                ROUNDED_CACHE,
+                (_TokenRead(TOKEN, 18, ROUNDED_BALANCE, ROUNDED_PRICE),),  # type: ignore[arg-type]
+            ),
+            {},
+        )
+        assert erc20.tokens[0].note == "in ERC20_VAULT_BALANCE"
+
     def test_symbols_name_the_holdings(self):
         symbols = {a.lower(): a.lower()[-2:] for a in (ASSET, TOKEN, OTHER)}
         erc20 = self._read(_erc20_state(), symbols)