ipor-fusion 4.2.0.dev16__tar.gz → 4.2.0.dev20__tar.gz

{ipor_fusion-4.2.0.dev16 → ipor_fusion-4.2.0.dev20}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: ipor-fusion
-Version: 4.2.0.dev16
+Version: 4.2.0.dev20
 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.2.0.dev16 → ipor_fusion-4.2.0.dev20}/examples/advanced_compound_v3_institutional_usdc_ethereum.py

@@ -260,7 +260,11 @@ def run_simulation(web3: Web3) -> SimulationResult:
     )
     factory = FusionFactory(ETHEREUM_FUSION_FACTORY)
 
-    # Preview the deterministic addresses (eth_call, no gas, no state change).
+    # SIMULATION ONLY: the pinned replay has no other clone between this
+    # preview and the simulated one, so the predicted stack is the created one.
+    # Live, another clone in between moves it: send the clone first, take the
+    # stack from factory.decode_clone_receipt(receipt) and build the
+    # configuration and operation calldata from those addresses.
     preview = factory.clone(**clone_args()).call(ctx)
     log.info("predicted vault=%s", preview.plasma_vault)
 
@@ -278,6 +282,9 @@ def run_simulation(web3: Web3) -> SimulationResult:
     #     (or X.calldata to a multisig / timelock).
     #   - sim.execute([action]) -> plasma_vault.execute([action]).send(ctx) by the alpha.
     #   - read = sim.observe(X), then read.value -> X.call(ctx), a plain read.
+    # SIMULATION ONLY (per-call senders): `from_` lets one process act as every
+    # actor, because in simulation they are addresses with no keys. In production
+    # they are separate signers on separate systems.
     sim = VaultSimulator(
         web3=web3, vault=vault_address, alpha=ALPHA, block=PINNED_BLOCK
     )
@@ -311,7 +318,8 @@ def run_simulation(web3: Web3) -> SimulationResult:
     # UPDATE_MARKETS_BALANCES}, so OWNER must self-grant ATOMIST before it can
     # grant the rest. Each grant uses Period(0) (no execution delay) to keep the
     # simulation legible; production governance often puts a nonzero delay -- a
-    # timelock -- on the sensitive roles.
+    # timelock -- on the sensitive roles. ALPHA must stay a separate address from
+    # OWNER in production: a compromised alpha key must not equal governance.
     for role, holder in (
         (Roles.ATOMIST_ROLE, OWNER),
         (Roles.FUSE_MANAGER_ROLE, OWNER),

{ipor_fusion-4.2.0.dev16 → ipor_fusion-4.2.0.dev20}/pyproject.toml

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

{ipor_fusion-4.2.0.dev16 → ipor_fusion-4.2.0.dev20}/src/ipor_fusion/readers/lending_health.py

@@ -298,6 +298,8 @@ def _compute_morpho_market_health(
         position.borrow_shares, market.total_borrow_assets, market.total_borrow_shares
     )
 
+    # Morpho's own check sees a zero borrow limit here, so the position can be
+    # liquidated: a known risk, of which only the LTV has no value.
     if position.collateral == 0 or oracle_price == 0:
         return LendingMarketHealth(
             protocol="morpho",
@@ -305,7 +307,7 @@ def _compute_morpho_market_health(
             market_name=market_name,
             current_ltv=None,
             max_ltv=params.lltv / WAD,
-            health_factor=None,
+            health_factor=0.0,
             total_collateral_usd=None,
             total_debt_usd=None,
             ltv_usage_percent=None,
@@ -322,9 +324,9 @@ def _compute_morpho_market_health(
     max_ltv = params.lltv / WAD
 
     # health_factor = max_borrow / borrowed
-    # max_borrow = collateral * oracle_price / ORACLE_PRICE_SCALE * lltv / WAD
+    # Two floors, as in Morpho's _isHealthy.
     max_borrow = (
-        position.collateral * oracle_price * params.lltv // (ORACLE_PRICE_SCALE * WAD)
+        position.collateral * oracle_price // ORACLE_PRICE_SCALE * params.lltv // WAD
     )
     health_factor = max_borrow / borrowed if borrowed > 0 else None
 
@@ -336,7 +338,7 @@ def _compute_morpho_market_health(
         market_name=market_name,
         current_ltv=round(current_ltv, 6),
         max_ltv=round(max_ltv, 6),
-        health_factor=round(health_factor, 4) if health_factor else None,
+        health_factor=round(health_factor, 4) if health_factor is not None else None,
         total_collateral_usd=None,
         total_debt_usd=None,
         ltv_usage_percent=round(ltv_usage, 2) if ltv_usage is not None else None,
@@ -574,9 +576,17 @@ def _compute_euler_v2_account_health(
         if ltv > 0
     )
     liability = liquidity.liability_value
+    # The vault owes, yet its oracle values that at nothing: no ratio means anything.
+    if liability == 0:
+        return UnreadableLendingMarket(
+            protocol="euler_v2",
+            market_id=ipor_market_id,
+            market_name=market_name,
+            reason="debt is valued at zero",
+            substrate_id=sub_account,
+        )
     current_ltv = liability / collateral if collateral > 0 else None
     max_ltv = adjusted / collateral if collateral > 0 else 0.0
-    health_factor = adjusted / liability if liability > 0 else None
     ltv_usage = liability / adjusted * 100 if adjusted > 0 else None
     # The USD unit of account prices in 18 decimals; other units are not USD.
     in_usd = unit_read.value == EULER_USD_UNIT_OF_ACCOUNT
@@ -587,7 +597,7 @@ def _compute_euler_v2_account_health(
         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(health_factor, 4) if health_factor is not None else None,
+        health_factor=round(adjusted / liability, 4),
         total_collateral_usd=round(collateral / WAD, 2) if in_usd else None,
         total_debt_usd=round(liability / WAD, 2) if in_usd else None,
         ltv_usage_percent=round(ltv_usage, 2) if ltv_usage is not None else None,

{ipor_fusion-4.2.0.dev16 → ipor_fusion-4.2.0.dev20}/src/ipor_fusion/validation.py

@@ -691,8 +691,9 @@ def _lending_health_findings(state: VaultState) -> list[Finding]:
         for u in health.unreadable
     ]
     for market in health.markets:
-        # 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:
+        # A row with neither value gives no risk metric to judge. Debt against a zero
+        # limit has no usage but a critical health factor.
+        if market.ltv_usage_percent is None and market.health_factor is None:
             continue
         ltv = f"{market.current_ltv:.4f}" if market.current_ltv is not None else "?"
         usage = (

{ipor_fusion-4.2.0.dev16 → ipor_fusion-4.2.0.dev20}/tests/test_cli_helpers.py

@@ -1532,6 +1532,18 @@ class TestPrintLendingHealth:
         _print_lending_health(data)
         assert "N/A" in capsys.readouterr().out
 
+    def test_debt_without_ltv_is_not_shown_as_no_debt(self, capsys):
+        m = _make_lending_market(
+            current_ltv=None, health_factor=0.0, ltv_usage_percent=None
+        )
+        m.protocol = "aave_v3"
+        m.market_id = MarketId(1)
+        data = _make_data(lending_health=VaultLendingHealth(markets=[m]))
+        _print_lending_health(data)
+        out = capsys.readouterr().out
+        assert "CRITICAL" in out
+        assert "no debt" not in out
+
 
 class TestHealthCheckLendingIntegration:
     def test_lending_ok_in_health_check(self, capsys):
@@ -1556,6 +1568,22 @@ class TestHealthCheckLendingIntegration:
         assert "CRITICAL" in captured.out
         assert "NEAR LIQUIDATION" in captured.out
 
+    def test_debt_without_ltv_is_critical_not_ok(self, capsys):
+        m = _make_lending_market(
+            current_ltv=None, ltv_usage_percent=None, health_factor=0.0
+        )
+        data = _make_data(lending_health=VaultLendingHealth(markets=[m]))
+        _print_health_check(validate(data, 100 * 10**18))
+        captured = capsys.readouterr()
+        assert "CRITICAL" in captured.out
+        assert "NEAR LIQUIDATION" in captured.out
+
+    def test_lending_warning_without_usage_is_reported(self, capsys):
+        m = _make_lending_market(ltv_usage_percent=None, health_factor=1.08)
+        data = _make_data(lending_health=VaultLendingHealth(markets=[m]))
+        _print_health_check(validate(data, 100 * 10**18))
+        assert "approaching liquidation" in capsys.readouterr().out
+
     def test_lending_none_usage_skipped(self, capsys):
         m = _make_lending_market(ltv_usage_percent=None, health_factor=None)
         data = _make_data(lending_health=VaultLendingHealth(markets=[m]))

{ipor_fusion-4.2.0.dev16 → ipor_fusion-4.2.0.dev20}/tests/test_cli_lending_health.py

@@ -419,6 +419,115 @@ class TestComputeMorphoMarketHealth:
         assert isinstance(result, LendingMarketHealth)
         assert result.current_ltv is None
         assert result.ltv_usage_percent is None
+        assert result.health_factor == 0.0
+        assert result.is_critical
+
+    def test_zero_oracle_price_with_debt_is_critical(self):
+        reader, ctx = _make_morpho_reader()
+
+        ctx.call.side_effect = sequenced(
+            [
+                encode(["uint256", "uint128", "uint128"], [0, 100, 1000]),
+                encode(
+                    ["uint128", "uint128", "uint128", "uint128", "uint128", "uint128"],
+                    [2000, 2000, 1000, 1000, 1700000000, 0],
+                ),
+                encode(
+                    ["address", "address", "address", "address", "uint256"],
+                    [TOKEN_A, TOKEN_B, ORACLE_ADDR, IRM_ADDR, 860000000000000000],
+                ),
+                encode(["uint256"], [0]),
+            ]
+        )
+
+        result = _compute_morpho_market_health(
+            ctx, reader, MORPHO_MARKET_ID, VAULT_ADDR, 14, "MORPHO"
+        )
+
+        assert isinstance(result, LendingMarketHealth)
+        assert result.current_ltv is None
+        assert result.health_factor == 0.0
+        assert result.is_critical
+
+    def test_dust_collateral_flooring_the_limit_to_zero_is_critical(self):
+        reader, ctx = _make_morpho_reader()
+
+        ctx.call.side_effect = sequenced(
+            [
+                encode(["uint256", "uint128", "uint128"], [0, 500 * 10**6, 1]),
+                encode(
+                    ["uint128", "uint128", "uint128", "uint128", "uint128", "uint128"],
+                    [2000, 2000 * 10**6, 1000, 1000 * 10**6, 1700000000, 0],
+                ),
+                encode(
+                    ["address", "address", "address", "address", "uint256"],
+                    [TOKEN_A, TOKEN_B, ORACLE_ADDR, IRM_ADDR, 860000000000000000],
+                ),
+                encode(["uint256"], [ORACLE_PRICE_SCALE]),
+            ]
+        )
+
+        result = _compute_morpho_market_health(
+            ctx, reader, MORPHO_MARKET_ID, VAULT_ADDR, 14, "MORPHO"
+        )
+
+        assert isinstance(result, LendingMarketHealth)
+        assert result.current_ltv is not None
+        assert result.health_factor == 0.0
+        assert result.is_critical
+
+    def test_limit_floors_twice_as_morpho_does(self):
+        # 2 * 0.9 floors to 1, then 1 * 0.86 floors to 0; one combined floor gives 1.
+        reader, ctx = _make_morpho_reader()
+
+        ctx.call.side_effect = sequenced(
+            [
+                encode(["uint256", "uint128", "uint128"], [0, 10**6, 2]),
+                encode(
+                    ["uint128", "uint128", "uint128", "uint128", "uint128", "uint128"],
+                    [2000, 2000 * 10**6, 1000, 1000 * 10**6, 1700000000, 0],
+                ),
+                encode(
+                    ["address", "address", "address", "address", "uint256"],
+                    [TOKEN_A, TOKEN_B, ORACLE_ADDR, IRM_ADDR, 860000000000000000],
+                ),
+                encode(["uint256"], [9 * ORACLE_PRICE_SCALE // 10]),
+            ]
+        )
+
+        result = _compute_morpho_market_health(
+            ctx, reader, MORPHO_MARKET_ID, VAULT_ADDR, 14, "MORPHO"
+        )
+
+        assert isinstance(result, LendingMarketHealth)
+        assert result.health_factor == 0.0
+
+    def test_debt_on_a_zero_lltv_market_is_critical_without_usage(self):
+        reader, ctx = _make_morpho_reader()
+
+        ctx.call.side_effect = sequenced(
+            [
+                encode(["uint256", "uint128", "uint128"], [0, 500 * 10**6, 1000]),
+                encode(
+                    ["uint128", "uint128", "uint128", "uint128", "uint128", "uint128"],
+                    [2000, 2000 * 10**6, 1000, 1000 * 10**6, 1700000000, 0],
+                ),
+                encode(
+                    ["address", "address", "address", "address", "uint256"],
+                    [TOKEN_A, TOKEN_B, ORACLE_ADDR, IRM_ADDR, 0],
+                ),
+                encode(["uint256"], [ORACLE_PRICE_SCALE]),
+            ]
+        )
+
+        result = _compute_morpho_market_health(
+            ctx, reader, MORPHO_MARKET_ID, VAULT_ADDR, 14, "MORPHO"
+        )
+
+        assert isinstance(result, LendingMarketHealth)
+        assert result.ltv_usage_percent is None
+        assert result.health_factor == 0.0
+        assert result.is_critical
 
     def test_position_read_failure_is_unreadable(self):
         reader, ctx = _make_morpho_reader()
@@ -1162,6 +1271,8 @@ def _euler_ctx(
     debt: int = EULER_DEBT,
     unit: str = EULER_USD_UNIT_OF_ACCOUNT,
     liquidity_reverts: bool = False,
+    adjusted: int = EULER_ADJUSTED_COLLATERAL,
+    liability: int = EULER_LIABILITY,
 ) -> MagicMock:
     """Answer the TESS sub-account's reads; only the borrow vault is its controller."""
 
@@ -1177,7 +1288,7 @@ def _euler_ctx(
                 raise ContractLogicError("E_NoLiability")
             return encode(
                 ["address[]", "uint256[]", "uint256"],
-                [[EULER_COLLATERAL], [EULER_ADJUSTED_COLLATERAL], EULER_LIABILITY],
+                [[EULER_COLLATERAL], [adjusted], liability],
             )
         if selector == _SELECTOR_UNIT_OF_ACCOUNT:
             return encode(["address"], [unit])
@@ -1241,6 +1352,19 @@ class TestEulerV2Health:
         assert result.total_collateral_usd is None
         assert result.total_debt_usd is None
 
+    @pytest.mark.parametrize("adjusted", [0, EULER_ADJUSTED_COLLATERAL])
+    def test_debt_valued_at_zero_is_unreadable_not_no_debt(self, adjusted):
+        result = _compute_euler_v2_account_health(
+            _euler_ctx(adjusted=adjusted, liability=0),
+            EULER_ACCOUNT,
+            MarketId(11),
+            "EULER_V2",
+        )
+
+        assert isinstance(result, UnreadableLendingMarket)
+        assert result.substrate_id == EULER_SUB_ACCOUNT
+        assert result.reason == "debt is valued at zero"
+
     def test_failed_debt_read_is_unreadable(self):
         ctx = MagicMock()
         ctx.call.side_effect = Web3RPCError("rpc down")

{ipor_fusion-4.2.0.dev16 → ipor_fusion-4.2.0.dev20}/tests/test_mcp_models.py

@@ -33,6 +33,7 @@ from ipor_fusion import (
     ExecutePreflightJson,
     Fee,
     FuseAddress,
+    IporFusionMarkets,
     MarketId,
     MetaMorphoV1Json,
     MetaMorphoV2Json,
@@ -72,6 +73,12 @@ from ipor_fusion.mcp.models import (
     VaultValidationResponse,
     WithdrawManagerDetails,
 )
+from ipor_fusion.readers.lending_health import (
+    LendingMarketHealth as LendingMarketHealthRow,
+)
+from ipor_fusion.readers.lending_health import (
+    VaultLendingHealth,
+)
 from ipor_fusion.readers.oracle_mapping import (
     OracleAsset,
     OracleMapping,
@@ -79,6 +86,7 @@ from ipor_fusion.readers.oracle_mapping import (
     OraclePrice,
 )
 from ipor_fusion.types import Period, RoleId
+from ipor_fusion.vault_info import _lending_health_json
 
 
 def _amount(raw: int = 0, formatted: str = "0") -> AmountJson:
@@ -1307,3 +1315,26 @@ class TestModelsImportGraph:
             }
         )
         assert offending == []
+
+
+def test_debt_without_ltv_passes_through_the_published_model() -> None:
+    row = LendingMarketHealthRow(
+        protocol="morpho",
+        market_id=IporFusionMarkets.MORPHO,
+        market_name="MORPHO",
+        current_ltv=None,
+        max_ltv=0.86,
+        health_factor=0.0,
+        total_collateral_usd=None,
+        total_debt_usd=None,
+        ltv_usage_percent=None,
+        substrate_id="0x" + "ab" * 32,
+    )
+
+    document = _lending_health_json(VaultLendingHealth(markets=[row]))
+    model = mcp_models.LendingHealth.model_validate(document)
+
+    market = model.markets[0]
+    assert market.health_factor == 0.0
+    assert market.current_ltv is None
+    assert market.is_critical