ipor-fusion 4.0.0.dev191__tar.gz → 4.0.0.dev194__tar.gz

{ipor_fusion-4.0.0.dev191 → ipor_fusion-4.0.0.dev194}/MIGRATION_4.md

@@ -950,6 +950,16 @@ 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.
 
+- **Morpho shares convert to assets as Morpho Blue does.** The position breakdown
+  (`MorphoReader.read_position_breakdown`, the `vault info` Morpho rows) and the Morpho
+  lending health follow `SharesMathLib`: integer math with 1e6 virtual shares and one
+  virtual asset, borrow rounded up, supply rounded down, on the market totals Morpho
+  stores (interest accrued since the market's last update is not included). 3.x
+  converted borrow shares by dividing by `total_shares + 1` in floating point and
+  supply shares without the virtual offsets, so large positions lost their low digits
+  and small or empty markets could be off by orders of magnitude: expect materially
+  different numbers where they were wrong.
+
 - **MCP `outputSchema` describes every nested block.** The tool output is
   byte-identical; the schemas of `vault_info`, `vault_oracle_mapping`,
   `market_morpho_blue` and `market_meta_morpho` replace each free-form object with

{ipor_fusion-4.0.0.dev191 → ipor_fusion-4.0.0.dev194}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: ipor-fusion
-Version: 4.0.0.dev191
+Version: 4.0.0.dev194
 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.dev191 → ipor_fusion-4.0.0.dev194}/pyproject.toml

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

{ipor_fusion-4.0.0.dev191 → ipor_fusion-4.0.0.dev194}/src/ipor_fusion/readers/lending_health.py

@@ -7,7 +7,6 @@ for lending positions held by Plasma Vaults.
 from __future__ import annotations
 
 import logging
-import math
 from concurrent.futures import ThreadPoolExecutor
 from dataclasses import dataclass
 
@@ -24,6 +23,7 @@ from ipor_fusion.readers.aave_v4 import AaveV4OracleReader, AaveV4SpokeReader
 from ipor_fusion.readers.morpho import (
     MorphoReader,
     morpho_blue_address,
+    to_assets_up,
 )
 from ipor_fusion.substrates import decode_substrate, market_name
 from ipor_fusion.types import (
@@ -145,13 +145,6 @@ def _call_morpho_oracle_price(ctx: Web3Context, oracle_address: ChecksumAddress)
     return price
 
 
-def _shares_to_assets_up(shares: int, total_assets: int, total_shares: int) -> int:
-    """Convert shares to assets, rounding up (Morpho convention)."""
-    if total_shares == 0:
-        return shares
-    return math.ceil(shares * (total_assets + 1) / (total_shares + 1))
-
-
 def _compute_morpho_market_health(
     ctx: Web3Context,
     reader: MorphoReader,
@@ -197,7 +190,7 @@ def _compute_morpho_market_health(
         _logger.debug("Failed to read Morpho oracle price for %s", morpho_market_id)
         return None
 
-    borrowed = _shares_to_assets_up(
+    borrowed = to_assets_up(
         position.borrow_shares, market.total_borrow_assets, market.total_borrow_shares
     )
 

{ipor_fusion-4.0.0.dev191 → ipor_fusion-4.0.0.dev194}/src/ipor_fusion/readers/morpho.py

@@ -62,6 +62,26 @@ def morpho_blue_address(chain_id: ChainId) -> ChecksumAddress:
     )
 
 
+# Morpho Blue's SharesMathLib: virtual shares and assets offset every
+# conversion, so a market's first depositor cannot inflate the share price.
+VIRTUAL_SHARES = 10**6
+VIRTUAL_ASSETS = 1
+
+
+def to_assets_down(shares: int, total_assets: int, total_shares: int) -> Amount:
+    """``SharesMathLib.toAssetsDown``: supply shares to assets, rounded down."""
+    return Amount(
+        shares * (total_assets + VIRTUAL_ASSETS) // (total_shares + VIRTUAL_SHARES)
+    )
+
+
+def to_assets_up(shares: int, total_assets: int, total_shares: int) -> Amount:
+    """``SharesMathLib.toAssetsUp``: borrow shares to assets, rounded up."""
+    numerator = shares * (total_assets + VIRTUAL_ASSETS)
+    denominator = total_shares + VIRTUAL_SHARES
+    return Amount((numerator + denominator - 1) // denominator)
+
+
 @dataclass(slots=True)
 class MorphoMarket:
     """On-chain state of a Morpho Blue lending market."""
@@ -206,22 +226,12 @@ class MorphoReader(ContractWrapper):
         params_read = batch.add(self.market_params(market_id))
         batch.run()
         pos, market, params = pos_read.value, market_read.value, params_read.value
-        if market.total_borrow_shares > 0:
-            borrow_assets = math.ceil(
-                pos.borrow_shares
-                * (market.total_borrow_assets + 1)
-                / (market.total_borrow_shares + 1)
-            )
-        else:
-            borrow_assets = 0
-        if market.total_supply_shares > 0:
-            supply_assets = (
-                pos.supply_shares
-                * market.total_supply_assets
-                // market.total_supply_shares
-            )
-        else:
-            supply_assets = 0
+        borrow_assets = to_assets_up(
+            pos.borrow_shares, market.total_borrow_assets, market.total_borrow_shares
+        )
+        supply_assets = to_assets_down(
+            pos.supply_shares, market.total_supply_assets, market.total_supply_shares
+        )
         return MorphoPositionBreakdown(
             market_id=market_id,
             loan_token=params.loan_token,

{ipor_fusion-4.0.0.dev191 → ipor_fusion-4.0.0.dev194}/tests/test_cli_lending_health.py

@@ -22,10 +22,14 @@ from ipor_fusion.readers.lending_health import (
     _compute_aave_market_health,
     _compute_aave_v4_market_health,
     _compute_morpho_market_health,
-    _shares_to_assets_up,
     fetch_vault_lending_health,
 )
-from ipor_fusion.readers.morpho import MorphoReader, morpho_blue_address
+from ipor_fusion.readers.morpho import (
+    MorphoReader,
+    morpho_blue_address,
+    to_assets_down,
+    to_assets_up,
+)
 from ipor_fusion.types import ChainId, MorphoBlueMarketId
 
 VAULT_ADDR = Web3.to_checksum_address("0x1111111111111111111111111111111111111111")
@@ -100,22 +104,44 @@ def _aave_account_data(health_factor_wad: int) -> bytes:
     )
 
 
-# ── shares_to_assets_up ──────────────────────────────────────────────
-
-
-class TestSharesToAssetsUp:
-    def test_zero_shares(self):
-        assert _shares_to_assets_up(0, 1000, 1000) == 0
+# ── SharesMathLib ─────────────────────────────────────────────────────
 
-    def test_zero_total_shares(self):
-        assert _shares_to_assets_up(100, 1000, 0) == 100
+# Vectors worked by hand from Morpho Blue's SharesMathLib (VIRTUAL_SHARES = 1e6,
+# VIRTUAL_ASSETS = 1): toAssetsDown = shares * (assets + 1) / (shares_total + 1e6)
+# rounded down, toAssetsUp the same rounded up (mulDivUp).
 
-    def test_rounds_up(self):
-        # 100 * (1001) / (1001) = 100, but with non-round: 3 * 1001 / 4 = 750.75 → 751
-        assert _shares_to_assets_up(3, 1000, 3) == 751
 
-    def test_exact_division(self):
-        assert _shares_to_assets_up(500, 1000, 1000) == 500
+class TestSharesMath:
+    def test_zero_shares(self):
+        assert to_assets_up(0, 1000, 1000) == 0
+        assert to_assets_down(0, 1000, 1000) == 0
+
+    def test_an_empty_market_still_divides_by_the_virtual_shares(self):
+        # 100 * 1001 / 1_000_000 = 0.1001
+        assert to_assets_up(100, 1000, 0) == 1
+        assert to_assets_down(100, 1000, 0) == 0
+
+    def test_a_tiny_pool_is_dominated_by_the_virtual_shares(self):
+        # 3 * 1001 / 1_000_003 = 0.003003
+        assert to_assets_up(3, 1000, 3) == 1
+        assert to_assets_down(3, 1000, 3) == 0
+
+    def test_realistic_share_scale_converts_back_to_assets(self):
+        # Shares minted at 1e6 per asset, then 250 assets of interest:
+        # 500e6 * 1_500_251 / (1.5e12 + 1e6) = 500.0833..., so up 501, down 500.
+        assert to_assets_up(500 * 10**6, 1_500_250, 1_500_000 * 10**6) == 501
+        assert to_assets_down(500 * 10**6, 1_500_250, 1_500_000 * 10**6) == 500
+
+    def test_large_values_keep_integer_precision(self):
+        # shares / total_shares = 1 / 1000 of 987654321987654321987 assets (+1):
+        # 987654321987654321.988 before the virtual-share correction, so the
+        # exact results straddle ...321 / ...322; a float division loses the
+        # last two digits (it gave 987654321987654272).
+        shares = 123456789123456789123456789
+        total_shares = shares * 1000
+        assets = 987654321987654321987
+        assert to_assets_up(shares, assets, total_shares) == 987654321987654322
+        assert to_assets_down(shares, assets, total_shares) == 987654321987654321
 
 
 # ── LendingMarketHealth properties ───────────────────────────────────
@@ -290,8 +316,8 @@ class TestComputeMorphoMarketHealth:
         reader, ctx = _make_morpho_reader()
 
         # 50% LTV scenario:
-        # borrow_shares=500, total_borrow_assets=1000, total_borrow_shares=1000
-        # → borrowed ≈ 500
+        # borrow_shares=500e6, total_borrow_assets=1000, total_borrow_shares=1000e6
+        # (Morpho mints 1e6 shares per asset) → borrowed = 500
         # collateral=1000, oracle_price=1e36 (1:1 price)
         # → collateral_value = 1000
         # → current_ltv = 500/1000 = 0.5
@@ -300,11 +326,11 @@ class TestComputeMorphoMarketHealth:
         ctx.call.side_effect = sequenced(
             [
                 # position
-                encode(["uint256", "uint128", "uint128"], [0, 500, 1000]),
+                encode(["uint256", "uint128", "uint128"], [0, 500 * 10**6, 1000]),
                 # market
                 encode(
                     ["uint128", "uint128", "uint128", "uint128", "uint128", "uint128"],
-                    [2000, 2000, 1000, 1000, 1700000000, 0],
+                    [2000, 2000 * 10**6, 1000, 1000 * 10**6, 1700000000, 0],
                 ),
                 # market_params
                 encode(
@@ -336,10 +362,10 @@ class TestComputeMorphoMarketHealth:
         # borrowed ≈ 830, collateral=1000, oracle_price=1e36
         ctx.call.side_effect = sequenced(
             [
-                encode(["uint256", "uint128", "uint128"], [0, 830, 1000]),
+                encode(["uint256", "uint128", "uint128"], [0, 830 * 10**6, 1000]),
                 encode(
                     ["uint128", "uint128", "uint128", "uint128", "uint128", "uint128"],
-                    [2000, 2000, 1000, 1000, 1700000000, 0],
+                    [2000, 2000 * 10**6, 1000, 1000 * 10**6, 1700000000, 0],
                 ),
                 encode(
                     ["address", "address", "address", "address", "uint256"],

{ipor_fusion-4.0.0.dev191 → ipor_fusion-4.0.0.dev194}/tests/test_reader_encoding.py

@@ -320,13 +320,15 @@ class TestAaveV3FuseReaderPool:
 class TestMorphoReaderPositionBreakdown:
     def test_position_breakdown_converts_shares_to_assets(self):
         reader, ctx = _make_reader(MorphoReader)
-        # position(): supply_shares=1000, borrow_shares=500, collateral=42
-        position_raw = encode(["uint256", "uint128", "uint128"], [1000, 500, 42])
-        # market(): supply_assets=2_000_000, supply_shares=2_000_000,
-        #          borrow_assets=1_500_000, borrow_shares=1_500_000
+        # position(): supply_shares=1000e6, borrow_shares=500e6, collateral=42
+        position_raw = encode(
+            ["uint256", "uint128", "uint128"], [1000 * 10**6, 500 * 10**6, 42]
+        )
+        # market(): supply 2_000_100 assets / 2_000_000e6 shares,
+        #           borrow 1_500_250 assets / 1_500_000e6 shares (accrued interest)
         market_raw = encode(
             ["uint128", "uint128", "uint128", "uint128", "uint128", "uint128"],
-            [2_000_000, 2_000_000, 1_500_000, 1_500_000, 1700000000, 0],
+            [2_000_100, 2_000_000 * 10**6, 1_500_250, 1_500_000 * 10**6, 1700000000, 0],
         )
         params_raw = encode(
             ["address", "address", "address", "address", "uint256"],
@@ -341,9 +343,10 @@ class TestMorphoReaderPositionBreakdown:
         assert result.loan_token == TOKEN_A
         assert result.collateral_token == TOKEN_B
         assert result.collateral == 42
-        # borrow_assets = ceil(500 * (1_500_000+1) / (1_500_000+1)) = 500
-        assert result.borrow_assets == 500
-        # supply_assets = 1000 * 2_000_000 // 2_000_000 = 1000
+        # SharesMathLib.toAssetsUp: ceil(500e6 * 1_500_251 / (1_500_000e6 + 1e6))
+        # = ceil(500.0833...) = 501
+        assert result.borrow_assets == 501
+        # toAssetsDown: 1000e6 * 2_000_101 // (2_000_000e6 + 1e6) = 1000 (1000.0495...)
         assert result.supply_assets == 1000
 
     def test_position_breakdown_handles_empty_market(self):