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

{ipor_fusion-4.0.0.dev191 → ipor_fusion-4.0.0.dev200}/AGENTS.md

@@ -513,7 +513,20 @@ decoder adds its own fields.
 - `ZeroBalanceFuse` markets are capabilities (swap, flash-loan,
   instant-withdrawal, admin) with structurally zero balance, not venues. They
   go in `zero_balance_fuses` and are not counted as liquidity markets.
-- Reconciliation: `totalAssets = balance_fuses_sum + underlying_on_vault`.
+- Reconciliation: `totalAssets = balance_fuses_sum + underlying_on_vault +
+  rewards_manager_balance` (`PlasmaVault._getGrossTotalAssets` adds
+  `IRewardsClaimManager.balanceOf()`, the vested rewards, when a manager is set;
+  0 without one; a manager or balance that cannot be read is a
+  `rewards_manager_balance` warning, and pre-rename vaults answer
+  `getRewardsManagerAddress()`). Vaults built from contracts before ipor-fusion
+  #475 (Feb 2026), the August 2024 audit generation included, return gross minus
+  the unrealized management fee; later ones return gross. The deployed version
+  is not readable, so the reconciliation decides by behavior: it nets the fee
+  (`management_fee_netted`) when `totalAssets` equals `max(0, gross - fee)` and not
+  `gross`, with gross built from the stored global market total
+  (`PlasmaVault.read_stored_markets_total`, an ERC-7201 slot), never from the
+  per-market caches.
+  Never key it on the legacy-getter or pre-audit detection.
   Balance fuses already price non-underlying ERC20s (e.g. ERC20BalanceFuse
   values BOLD + BOLDUSDC-gauge in WETH terms). Never add all ERC20 values on
   top of balance fuse totals; that double-counts. `erc20_direct_total` in JSON

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

@@ -639,7 +639,7 @@ converted amounts `Amount`. A custom `VaultState` annotates the same.
 `Shares` (vault shares), and `transfer` / `approve` / `transfer_from` /
 `set_total_supply_cap` take `Shares`; `ERC20` keeps `Amount`.
 `Reconciliation` amounts (`balance_fuses_total`, `underlying_on_vault`,
-`erc20_direct_total`, `sum`, `on_chain_total_assets`, `delta`,
+`rewards_manager_balance`, `erc20_direct_total`, `sum`, `on_chain_total_assets`, `delta`,
 `pending_withdrawals`, `implied_market_total`, `market_storage_divergence`) are
 `Amount`. `FusionInstance.asset_decimals` / `underlying_token_decimals` are
 `Decimals`, and `CloneArgs.redemption_delay_seconds` is a `Period`.
@@ -950,6 +950,39 @@ 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.
 
+- **The reconciliation counts the rewards claim manager.** `PlasmaVault.totalAssets`
+  adds `RewardsClaimManager.balanceOf()` (vested rewards) to the vault's idle
+  underlying and its markets; 3.x left it out, so a vault with vested rewards showed
+  a delta of that size and an inflated `implied_market_total` (a false market-storage
+  drift). `fetch_vault_data` reads it into `VaultData.rewards_manager_balance` (0
+  without a manager, `None` when the read fails, which validation reports as a
+  `rewards_manager_balance` warning), and `Reconciliation`, the `vault info` and
+  `vault validate` documents carry a `rewards_manager_balance` amount. A custom
+  `VaultState` adds the `rewards_manager_balance` property, and code constructing a
+  `Reconciliation` passes `rewards_manager_balance` and `rewards_manager_balance_usd`.
+
+- **The reconciliation follows the vault's `totalAssets` formula.** Contracts before
+  ipor-fusion #475 (Feb 2026) return gross assets minus the unrealized management
+  fee, later ones gross. 3.x always compared gross, so every older vault with an
+  accrued fee showed that fee as a delta. The reconciliation now subtracts the
+  fee (`Reconciliation.management_fee_netted`, also in both JSON documents) when
+  `totalAssets` equals `max(0, gross - fee)` rather than `gross`, gross built from
+  the global market total the vault stores (`VaultData.stored_markets_total`, read
+  by `PlasmaVault.read_stored_markets_total`); the vault's age plays no part. A
+  custom `VaultState` adds the `unrealized_management_fee` (`VaultData` derives it
+  from `fee_data`) and `stored_markets_total` properties; code constructing a
+  `Reconciliation` passes `management_fee_netted` and `management_fee_netted_usd`.
+
+- **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.dev200}/PKG-INFO

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

@@ -1,6 +1,6 @@
 [project]
 name = "ipor-fusion"
-version = "4.0.0.dev191"
+version = "4.0.0.dev200"
 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.dev200}/src/ipor_fusion/cli/vault_health.py

@@ -73,6 +73,20 @@ def _print_reconciliation(data: VaultData, validation: VaultValidation) -> None:
     click.echo(
         f"  Underlying on vault:  {fmt_underlying} {sym}{usd_underlying}   [{sym} held directly]"
     )
+    if recon.rewards_manager_balance > 0:
+        fmt_rewards = _format_amount(recon.rewards_manager_balance, decimals)
+        usd_rewards = f" (${recon.rewards_manager_balance_usd:,.2f})" if price else ""
+        click.echo(
+            f"  Rewards manager:      {fmt_rewards} {sym}{usd_rewards}"
+            "   [vested rewards, in totalAssets]"
+        )
+    if recon.management_fee_netted > 0:
+        fmt_fee = _format_amount(recon.management_fee_netted, decimals)
+        usd_fee = f" (${recon.management_fee_netted_usd:,.2f})" if price else ""
+        click.echo(
+            f"  Management fee:      -{fmt_fee} {sym}{usd_fee}"
+            "   [unrealized, netted by totalAssets]"
+        )
     click.echo(f"  Sum:                  {fmt_sum} {sym}{usd_sum}")
     click.echo(f"  On-chain totalAssets: {fmt_onchain} {sym}{usd_onchain}")
     sign = "+" if recon.delta >= 0 else "-"

{ipor_fusion-4.0.0.dev191 → ipor_fusion-4.0.0.dev200}/src/ipor_fusion/core/plasma_vault.py

@@ -90,6 +90,15 @@ def _market_id_list_decoder(value: tuple[int, ...]) -> list[MarketId]:
 
 _BALANCE_OF_SELECTOR = function_signature_to_4byte_selector("balanceOf()")
 
+# PlasmaVaultStorageLib.PLASMA_VAULT_TOTAL_ASSETS_IN_ALL_MARKETS, and its value
+# before the June 2024 storage rename (ipor-fusion #43).
+_TOTAL_ASSETS_IN_ALL_MARKETS_SLOT = int(
+    "0x24e02552e88772b8e8fd15f3e6699ba530635ffc6b52322da922b0b497a77300", 16
+)
+_LEGACY_TOTAL_ASSETS_SLOT = int(
+    "0xf660efede6b8071aab61a75191de57a4a8a416b088f961d8c2a18168aa7c7700", 16
+)
+
 
 def _read_result_data(result: tuple[bytes]) -> bytes:
     """``ReadResult.data``, undecoded."""
@@ -449,6 +458,15 @@ class PlasmaVault(ContractWrapper):
             decoder=Web3.to_checksum_address,
         )
 
+    def get_rewards_manager_address(self) -> Call[ChecksumAddress]:
+        """The getter of vaults deployed before the manager was renamed
+        RewardsClaimManager (June 2024)."""
+        return self._view(
+            "getRewardsManagerAddress()",
+            output_types=["address"],
+            decoder=Web3.to_checksum_address,
+        )
+
     def get_performance_fee_data(self) -> Call[PerformanceFeeData]:
         return self._view(
             "getPerformanceFeeData()",
@@ -576,6 +594,16 @@ class PlasmaVault(ContractWrapper):
             for market_id, fuse in zip(market_ids, fuses, strict=True)
         ]
 
+    def read_stored_markets_total(self, ctx: Web3Context) -> Amount:
+        """The global market total the vault stores (the
+        ``totalAssetsInAllMarkets`` term of ``totalAssets``), read from its
+        ERC-7201 slot; vaults built before June 2024 keep it at an earlier slot,
+        read when the current one is empty."""
+        for slot in (_TOTAL_ASSETS_IN_ALL_MARKETS_SLOT, _LEGACY_TOTAL_ASSETS_SLOT):
+            if value := int.from_bytes(ctx.get_storage_at(self._address, slot)):
+                return Amount(value)
+        return Amount(0)
+
     def _address_at(self, ctx: Web3Context, slot: int) -> ChecksumAddress:
         return _address_in_word(ctx.get_storage_at(self._address, slot))
 

{ipor_fusion-4.0.0.dev191 → ipor_fusion-4.0.0.dev200}/src/ipor_fusion/mcp/models.py

@@ -397,6 +397,16 @@ class ERC20Entry(_Base):
 class Reconciliation(_Base):
     balance_fuses_total: Amount
     underlying_on_vault: Amount
+    rewards_manager_balance: Amount | None = Field(
+        default=None,
+        description="RewardsClaimManager.balanceOf(), which totalAssets includes; "
+        "0 without a manager or when it could not be read.",
+    )
+    management_fee_netted: Amount | None = Field(
+        default=None,
+        description="Unrealized management fee subtracted from sum: totalAssets "
+        "nets it on vaults built before ipor-fusion #475; 0 otherwise.",
+    )
     erc20_direct_total: Amount
     sum: Amount
     on_chain_total_assets: Amount
@@ -764,10 +774,19 @@ class FindingModel(_Base):
 
 
 class ReconciliationModel(_Base):
-    """totalAssets against balance fuses plus idle underlying."""
+    """totalAssets against balance fuses, idle underlying and the rewards
+    claim manager's balance."""
 
     balance_fuses_total: Amount
     underlying_on_vault: Amount
+    rewards_manager_balance: Amount = Field(
+        description="RewardsClaimManager.balanceOf(), which totalAssets includes; "
+        "0 without a manager or when it could not be read."
+    )
+    management_fee_netted: Amount = Field(
+        description="Unrealized management fee subtracted from sum: totalAssets "
+        "nets it on vaults built before ipor-fusion #475; 0 otherwise."
+    )
     erc20_direct_total: Amount = Field(
         description="Informational: already valued by the ERC20_VAULT_BALANCE "
         "balance fuse, never added to sum."
@@ -797,6 +816,12 @@ class ReconciliationModel(_Base):
             underlying_on_vault=amount(
                 rec.underlying_on_vault, rec.underlying_on_vault_usd
             ),
+            rewards_manager_balance=amount(
+                rec.rewards_manager_balance, rec.rewards_manager_balance_usd
+            ),
+            management_fee_netted=amount(
+                rec.management_fee_netted, rec.management_fee_netted_usd
+            ),
             erc20_direct_total=amount(
                 rec.erc20_direct_total, rec.erc20_direct_total_usd
             ),

{ipor_fusion-4.0.0.dev191 → ipor_fusion-4.0.0.dev200}/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.dev200}/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.dev200}/src/ipor_fusion/types.py

@@ -79,6 +79,7 @@ Severity: TypeAlias = Literal["ok", "warning", "critical"]
 Verdict: TypeAlias = Literal["ok", "warning", "critical"]
 Check: TypeAlias = Literal[
     "unimplemented_getter",
+    "rewards_manager_balance",
     "orphan_fuse",
     "missing_erc20_dependency",
     "unpriceable_token",

{ipor_fusion-4.0.0.dev191 → ipor_fusion-4.0.0.dev200}/src/ipor_fusion/validation.py

@@ -119,6 +119,22 @@ class VaultState(Protocol):
     def total_assets(self) -> Amount: ...
     @property
     def underlying_balance_on_vault(self) -> Amount: ...
+    @property
+    def stored_markets_total(self) -> Amount | None:
+        """The global market total the vault stores; None when not read."""
+        ...
+
+    @property
+    def unrealized_management_fee(self) -> Amount | None:
+        """``getUnrealizedManagementFee()``, None when not read."""
+        ...
+
+    @property
+    def rewards_manager_balance(self) -> Amount | None:
+        """The RewardsClaimManager's balanceOf(), part of totalAssets; 0
+        without a manager, None when it could not be read."""
+        ...
+
     @property
     def price_oracle(self) -> ChecksumAddress: ...
     @property
@@ -155,20 +171,30 @@ class Finding:
 
 @dataclass(frozen=True)
 class Reconciliation:
-    """``totalAssets`` against what the vault's markets and idle underlying add
-    up to. Raw amounts are in the underlying asset's decimals; ``*_usd`` values
+    """``totalAssets`` against what the vault's markets, idle underlying and
+    rewards claim manager add up to. Raw amounts are in the underlying asset's decimals; ``*_usd`` values
     are 0 when the asset has no USD price (``on_chain_total_assets_usd``:
     ``None``).
 
     Balance fuses already value non-underlying ERC20s (via
     ERC20_VAULT_BALANCE), so ``sum`` is balance fuses plus idle underlying
-    only; ``erc20_direct_total`` is informational and never added to it.
+    plus the rewards claim manager's balance, minus the unrealized management
+    fee where ``totalAssets`` nets it (``management_fee_netted``);
+    ``erc20_direct_total`` is informational and never added to it.
     """
 
     balance_fuses_total: Amount
     balance_fuses_total_usd: float
     underlying_on_vault: Amount
     underlying_on_vault_usd: float
+    # RewardsClaimManager.balanceOf(): vested rewards totalAssets counts
+    # (0 without a manager or when it could not be read).
+    rewards_manager_balance: Amount
+    rewards_manager_balance_usd: float
+    # The unrealized management fee totalAssets subtracts, on vaults whose
+    # contracts net it (before ipor-fusion #475); 0 on a vault returning gross.
+    management_fee_netted: Amount
+    management_fee_netted_usd: float
     erc20_direct_total: Amount
     erc20_direct_total_usd: float
     sum: Amount
@@ -181,7 +207,8 @@ class Reconciliation:
     # sharesToRelease of the WithdrawManager converted to assets.
     pending_withdrawals: Amount
     pending_withdrawals_usd: float
-    # totalAssets minus idle underlying: the global market total the vault
+    # totalAssets minus idle underlying and the rewards claim manager's
+    # balance: the global market total the vault
     # stores, which per-market caches drift from after partial refreshes.
     implied_market_total: Amount
 
@@ -259,6 +286,7 @@ def validate_vault_state(state: VaultState) -> VaultValidation:
     reconciliation = _reconcile(state)
     findings = [
         *_unimplemented_getter_findings(state),
+        *_rewards_manager_findings(state),
         *_orphan_fuse_findings(state),
         *_missing_erc20_dependency_findings(state),
         *_unpriceable_token_findings(state),
@@ -300,9 +328,15 @@ def _reconcile(state: VaultState) -> Reconciliation:
     if underlying > 0 and price:
         underlying_usd = (underlying / 10**decimals) * price
 
-    total = Amount(balance_fuses_total + underlying)
-    total_usd = balance_fuses_usd + underlying_usd
+    rewards = state.rewards_manager_balance or Amount(0)
+    rewards_usd = _usd(rewards, decimals, price)
+
     on_chain = state.total_assets
+    gross = Amount(balance_fuses_total + underlying + rewards)
+    fee = _netted_management_fee(state, underlying + rewards)
+    fee_usd = _usd(fee, decimals, price)
+    total = Amount(gross - fee)
+    total_usd = balance_fuses_usd + underlying_usd + rewards_usd - fee_usd
     delta = Amount(total - on_chain)
     delta_usd = abs(total_usd - (on_chain / 10**decimals * price)) if price else 0
     delta_percent = abs(delta / on_chain * 100) if on_chain else 0.0
@@ -325,6 +359,10 @@ def _reconcile(state: VaultState) -> Reconciliation:
         balance_fuses_total_usd=balance_fuses_usd,
         underlying_on_vault=underlying,
         underlying_on_vault_usd=underlying_usd,
+        rewards_manager_balance=rewards,
+        rewards_manager_balance_usd=rewards_usd,
+        management_fee_netted=fee,
+        management_fee_netted_usd=fee_usd,
         erc20_direct_total=erc20.value_in_asset,
         erc20_direct_total_usd=erc20.value_usd,
         sum=total,
@@ -336,10 +374,36 @@ def _reconcile(state: VaultState) -> Reconciliation:
         delta_percent=delta_percent,
         pending_withdrawals=pending,
         pending_withdrawals_usd=pending_usd,
-        implied_market_total=Amount(max(0, on_chain - underlying)),
+        implied_market_total=Amount(max(0, on_chain + fee - underlying - rewards)),
     )
 
 
+def _usd(amount: int, decimals: int, price: float | None) -> float:
+    return (amount / 10**decimals) * price if amount and price else 0.0
+
+
+def _netted_management_fee(state: VaultState, outside_markets: int) -> Amount:
+    """The unrealized management fee ``totalAssets`` subtracts, 0 when it
+    returns gross.
+
+    PlasmaVault contracts before ipor-fusion #475 (Feb 2026) return
+    ``max(0, gross - fee)``, later ones ``gross``, where gross is idle
+    underlying plus the stored global market total plus the rewards manager's
+    balance. The deployed version is not readable, so the formula is decided by
+    which one ``totalAssets`` matches, from the stored global total rather than
+    the per-market caches the reconciliation compares (a drift between those
+    must not pass for the fee). Without the stored total, the fee or a match,
+    nothing is netted.
+    """
+    fee, stored = state.unrealized_management_fee, state.stored_markets_total
+    if not fee or stored is None:
+        return Amount(0)
+    gross = outside_markets + stored
+    if state.total_assets == gross or state.total_assets != max(0, gross - fee):
+        return Amount(0)
+    return Amount(min(fee, gross))
+
+
 def _unimplemented_getter_findings(state: VaultState) -> list[Finding]:
     return [
         Finding(
@@ -351,6 +415,20 @@ def _unimplemented_getter_findings(state: VaultState) -> list[Finding]:
     ]
 
 
+def _rewards_manager_findings(state: VaultState) -> list[Finding]:
+    if state.rewards_manager_balance is not None:
+        return []
+    return [
+        Finding(
+            "rewards_manager_balance",
+            "warning",
+            "WARNING — the rewards claim manager or its balanceOf() could not be "
+            "read: totalAssets includes that balance, so the reconciliation "
+            "leaves it out and its delta may be that balance",
+        )
+    ]
+
+
 def _orphan_fuse_findings(state: VaultState) -> list[Finding]:
     """Action fuses whose market has no balance fuse: their positions silently
     bypass ``totalAssets``. Flow-through markets (flash loans, swaps) are
@@ -522,8 +600,13 @@ def _reconciliation_findings(
     symbol = state.asset_symbol
     expected = reconciliation.sum
     percent = abs(expected - total_assets) / total_assets * 100
+    terms = "Balance fuses + underlying"
+    if reconciliation.rewards_manager_balance > 0:
+        terms += " + rewards manager"
+    if reconciliation.management_fee_netted > 0:
+        terms += " - unrealized management fee"
     line = (
-        f"Balance fuses + underlying = {_format_amount(expected, decimals)} "
+        f"{terms} = {_format_amount(expected, decimals)} "
         f"{symbol} vs totalAssets {_format_amount(total_assets, decimals)} "
         f"{symbol} ({percent:.2f}%)"
     )
@@ -541,7 +624,9 @@ def _reconciliation_findings(
             )
         )
     divergence = reconciliation.market_storage_divergence
-    if abs(divergence) > 10**decimals:
+    # With the rewards manager's balance unknown the divergence may be that
+    # balance; the rewards_manager_balance warning says so instead.
+    if abs(divergence) > 10**decimals and state.rewards_manager_balance is not None:
         findings.append(
             Finding(
                 "market_storage_drift",

{ipor_fusion-4.0.0.dev191 → ipor_fusion-4.0.0.dev200}/src/ipor_fusion/vault_data.py

@@ -26,9 +26,10 @@ from ipor_fusion.core.access import AccessManager, RoleAccount, role_account_sor
 from ipor_fusion.core.context import Web3Context
 from ipor_fusion.core.contract import Call
 from ipor_fusion.core.erc20 import ERC20
-from ipor_fusion.core.multicall import Multicall3
+from ipor_fusion.core.multicall import BatchValue, Multicall3
 from ipor_fusion.core.oracle import PriceOracleMiddleware, price_oracle_middleware
 from ipor_fusion.core.plasma_vault import BalanceFuse, PlasmaVault
+from ipor_fusion.core.rewards_manager import RewardsManager
 from ipor_fusion.errors import (
     EmptyCallResultError,
     UnsupportedVaultVersionError,
@@ -143,6 +144,13 @@ class VaultData:
     # ERC20_VAULT_BALANCE substrate, so it is read directly in
     # fetch_vault_data rather than derived from substrates.
     underlying_balance_on_vault: Amount = Amount(0)
+    # RewardsClaimManager.balanceOf() (its vested underlying), which
+    # PlasmaVault.totalAssets adds to the vault's own balance and its markets.
+    # 0 without a manager; None when the vault has one but the read failed.
+    rewards_manager_balance: Amount | None = Amount(0)
+    # The global market total the vault stores (the totalAssetsInAllMarkets
+    # term of totalAssets); None when the storage read failed.
+    stored_markets_total: Amount | None = None
     vault_name: str = ""
     deployment_block: int | None = None
     deployment_timestamp: Timestamp | None = None
@@ -204,6 +212,11 @@ class VaultData:
     token_symbols: dict[HexAddress, str] = field(default_factory=dict)
     token_decimals: dict[HexAddress, Decimals | None] = field(default_factory=dict)
 
+    @property
+    def unrealized_management_fee(self) -> Amount | None:
+        """``getUnrealizedManagementFee()`` from the fee snapshot."""
+        return self.fee_data.unrealized_management_fee if self.fee_data else None
+
 
 _MARKET_ID_SELECTOR = function_signature_to_4byte_selector("MARKET_ID()")
 
@@ -342,6 +355,7 @@ class _VaultReads:
     asset_price_usd: float | None
     fuse_markets: dict[FuseAddress, MarketId] | None
     unimplemented_getters: list[str]
+    rewards_manager_balance: Amount | None
 
 
 def _fetch_vault_reads(
@@ -351,8 +365,9 @@ def _fetch_vault_reads(
     oracle wrapper resolved for them (reused, so its ABI is probed once).
 
     Two Multicall3 round trips: vault getters, then everything that needs the
-    asset, the oracle or the fuse list (asset metadata, idle balance, price,
-    each fuse's MARKET_ID()).
+    asset, the oracle, the fuse list or the rewards claim manager (asset
+    metadata, idle balance, price, each fuse's MARKET_ID(), the manager's
+    vested balance).
     """
     pv = plasma_vault
     batch = Multicall3(ctx).batch()
@@ -365,6 +380,7 @@ def _fetch_vault_reads(
     instant_fuses = batch.add(pv.get_instant_withdrawal_fuses())
     vault_name = batch.try_add(pv.name())
     rewards_manager = batch.try_add(pv.get_rewards_claim_manager_address())
+    legacy_rewards_manager = batch.try_add(pv.get_rewards_manager_address())
     supply_cap_read = batch.try_add(pv.get_total_supply_cap())
     middleware_oracle = batch.try_add(pv.get_price_oracle_middleware_address())
     legacy_oracle = batch.try_add(pv.get_price_oracle_address())
@@ -398,6 +414,18 @@ def _fetch_vault_reads(
     fuse_market_ids = [
         (fuse, batch.try_add(_fuse_market_id_call(fuse))) for fuse in fuses
     ]
+    # Vaults before the RewardsClaimManager rename answer the legacy getter;
+    # None from both leaves the manager, and so its balance, unknown.
+    manager = (
+        rewards_manager.value
+        if rewards_manager.value is not None
+        else legacy_rewards_manager.value
+    )
+    manager_balance = (
+        batch.try_add(RewardsManager(manager).balance_of())
+        if manager is not None and int(manager, 16) != 0
+        else None
+    )
     batch.run()
     # Fuses without a readable MARKET_ID() are left out; the rest detect orphan
     # markets (action fuse registered, no balance fuse for its market).
@@ -416,7 +444,8 @@ def _fetch_vault_reads(
         fuses=fuses,
         instant_fuses=instant_fuses.value,
         vault_name=vault_name.value or "",
-        rewards_manager=rewards_manager.value,
+        rewards_manager=manager,
+        rewards_manager_balance=_rewards_manager_balance(manager, manager_balance),
         asset_decimals=asset_decimals.value,
         underlying_balance_on_vault=underlying_balance.value,
         asset_symbol=symbol.value or "?",
@@ -426,6 +455,16 @@ def _fetch_vault_reads(
     ), oracle
 
 
+def _rewards_manager_balance(
+    manager: ChecksumAddress | None, read: BatchValue[Amount | None] | None
+) -> Amount | None:
+    """The manager's balance; 0 for the zero address (no manager), None when
+    the manager or its balance could not be read."""
+    if read is not None:
+        return read.value
+    return None if manager is None else Amount(0)
+
+
 def _fetch_role_accounts(
     ctx: Web3Context, plasma_vault: PlasmaVault
 ) -> list[RoleAccount] | None:
@@ -587,6 +626,9 @@ def fetch_vault_data(
         f_fees = pool.submit(_fetch_fee_data, ctx, plasma_vault)
         f_withdraw = pool.submit(_fetch_withdraw_manager, ctx, plasma_vault)
         f_roles = pool.submit(_fetch_role_accounts, ctx, plasma_vault)
+        f_stored_total = pool.submit(
+            _safe_call, partial(plasma_vault.read_stored_markets_total, ctx)
+        )
         f_markets = pool.submit(
             _fetch_market_reads, ctx, plasma_vault, with_aave_pools=lending
         )
@@ -622,6 +664,7 @@ def fetch_vault_data(
             fee_data=f_fees.result(),
             role_accounts=f_roles.result(),
             hypercore=f_hypercore.result(),
+            stored_markets_total=f_stored_total.result(),
         )
 
 
@@ -645,6 +688,7 @@ def _snapshot(
     fee_data: FeeData | None,
     role_accounts: list[RoleAccount] | None,
     hypercore: HyperCoreVaultState | None,
+    stored_markets_total: Amount | None,
 ) -> VaultData:
     """`VaultData` from the pipelines' results."""
     return VaultData(
@@ -664,6 +708,8 @@ def _snapshot(
         instant_fuses=reads.instant_fuses,
         vault_name=reads.vault_name,
         rewards_manager=reads.rewards_manager,
+        rewards_manager_balance=reads.rewards_manager_balance,
+        stored_markets_total=stored_markets_total,
         asset_decimals=reads.asset_decimals,
         underlying_balance_on_vault=reads.underlying_balance_on_vault,
         asset_symbol=reads.asset_symbol,

{ipor_fusion-4.0.0.dev191 → ipor_fusion-4.0.0.dev200}/src/ipor_fusion/vault_info.py

@@ -305,6 +305,8 @@ class Erc20BalanceJson(TypedDict):
 class ReconciliationJson(TypedDict):
     balance_fuses_total: UsdAmountJson
     underlying_on_vault: UsdAmountJson
+    rewards_manager_balance: UsdAmountJson
+    management_fee_netted: UsdAmountJson
     erc20_direct_total: UsdAmountJson
     sum: UsdAmountJson
     on_chain_total_assets: UsdAmountJson
@@ -810,6 +812,14 @@ def _reconciliation_json(recon: Reconciliation, decimals: int) -> Reconciliation
         "underlying_on_vault": _amount_json(
             recon.underlying_on_vault, decimals, recon.underlying_on_vault_usd
         ),
+        "rewards_manager_balance": _amount_json(
+            recon.rewards_manager_balance,
+            decimals,
+            recon.rewards_manager_balance_usd,
+        ),
+        "management_fee_netted": _amount_json(
+            recon.management_fee_netted, decimals, recon.management_fee_netted_usd
+        ),
         "erc20_direct_total": _amount_json(
             recon.erc20_direct_total, decimals, recon.erc20_direct_total_usd
         ),