ipor-fusion 4.0.0.dev120__tar.gz → 4.0.0.dev122__tar.gz

{ipor_fusion-4.0.0.dev120 → ipor_fusion-4.0.0.dev122}/AGENTS.md

@@ -429,9 +429,10 @@ are not validated.
   everything validation and the ``vault info`` document need, so neither reads the
   chain. The chain is `ctx.chain_id`; ``lending=False`` skips lending health, the
   position breakdowns, their prices and the unpriceable check; ``metadata=False``
-  reads no token symbol or decimals at all (`validate_vault`'s default), and
-  ``metadata=True`` reads them in one cached Multicall3 batch that also names the
-  ERC20 holdings. Add a new chain-state input to the snapshot, never a
+  (`validate_vault`'s default) skips the display metadata (`token_symbols`,
+  `token_decimals`, the ERC20 holdings' symbols) but not the asset's symbol and
+  decimals or the decimals valuation needs; ``metadata=True`` reads it in one cached
+  Multicall3 batch that also names the ERC20 holdings. Add a new chain-state input to the snapshot, never a
   read inside a renderer or validator.
 - PlasmaVault serves governance/view functions via `fallback()` delegatecall to
   PlasmaVaultBase, so Etherscan's ABI for the vault address omits callable

{ipor_fusion-4.0.0.dev120 → ipor_fusion-4.0.0.dev122}/MIGRATION_4.md

@@ -65,14 +65,15 @@ chain is always the context's:
   the vault address (not a `PlasmaVault`) and no `chain_id`. It resolves one block
   (``block``, else a numeric `ctx.default_block`, else the latest) and runs every
   read, log scans included, on `ctx.at_block(block)`; `ctx` is not modified. The old
-  ``chain_id=0`` switch is ``lending=False``; ``metadata=False`` reads no token
-  symbol or decimals (the ERC20 holdings' symbols are then `"?"`), and with
-  ``metadata=True`` the holdings are named by the same cached, batched read as
-  `token_symbols`. `VaultData` gains `vault`, `chain_id`, `market_balances`, `erc20`,
+  ``chain_id=0`` switch is ``lending=False``; ``metadata=False`` skips the
+  display metadata: `token_symbols` and `token_decimals` stay empty and the ERC20
+  holdings' symbols are `"?"`. The underlying asset's symbol and decimals and the
+  decimals the valuation needs are still read. With ``metadata=True`` the holdings
+  are named by the same cached, batched read as `token_symbols`. `VaultData` gains `vault`, `chain_id`, `market_balances`, `erc20`,
   `token_symbols` and `token_decimals`; `WithdrawManagerData` gains
   `shares_to_release_assets` and `pending_request_assets`.
 - `validate_vault(ctx, vault, *, block=None, metadata=False)` fetches (by default
-  without token metadata) and validates; it no longer takes ``resolve_symbol``.
+  without display metadata) and validates; it no longer takes ``resolve_symbol``.
   ``metadata=True`` names the ERC20 holdings in the result and its findings. `validate_vault_state(state)` is
   pure: a custom `VaultState` also provides `vault`, `chain_id`, `market_balances`,
   `erc20` and the queue's `shares_to_release_assets`. `read_erc20_holdings` is gone:

{ipor_fusion-4.0.0.dev120 → ipor_fusion-4.0.0.dev122}/PKG-INFO

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

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

{ipor_fusion-4.0.0.dev120 → ipor_fusion-4.0.0.dev122}/src/ipor_fusion/validation.py

@@ -245,9 +245,10 @@ def validate_vault(
     else the context's numeric default block, else the latest) and validate
     it; ``ctx`` itself is not modified.
 
-    The checks need no token metadata, so none is read by default and the
-    ERC20 holdings are named ``"?"``; ``metadata=True`` adds one batched,
-    cached symbol read that names them in the holdings and findings."""
+    The checks need no display metadata, so by default the snapshot has no
+    `token_symbols` / `token_decimals` and the ERC20 holdings are named
+    ``"?"``; ``metadata=True`` adds one batched, cached read that names them
+    in the holdings and findings."""
     return validate_vault_state(
         fetch_vault_data(ctx, vault, block=block, metadata=metadata)
     )

{ipor_fusion-4.0.0.dev120 → ipor_fusion-4.0.0.dev122}/src/ipor_fusion/vault_data.py

@@ -549,8 +549,10 @@ def fetch_vault_data(
     ``lending=False`` skips lending health, the Morpho / Aave position
     breakdowns, their token prices and the unpriceable-token check.
     ``metadata=False`` skips the token symbols and decimals the ``vault info``
-    document shows (validation does not need them) and reads no symbol at all:
-    the ERC20 holdings are then named ``"?"``.
+    document shows (validation does not need them): `token_symbols` and
+    `token_decimals` stay empty and the ERC20 holdings are named ``"?"``. The
+    underlying asset's symbol and decimals and the decimals the valuation needs
+    are read either way.
 
     Raises `UnsupportedChainError` on a chain the tooling is not validated on
     and `UnsupportedVaultVersionError` when the vault predates a getter the

{ipor_fusion-4.0.0.dev120 → ipor_fusion-4.0.0.dev122}/tests/test_validation.py

@@ -8,7 +8,6 @@ depends on the CLI's fetch types.
 from __future__ import annotations
 
 import dataclasses
-from concurrent.futures import ThreadPoolExecutor
 from dataclasses import dataclass, field, replace
 from typing import Any
 from unittest.mock import MagicMock, patch
@@ -30,13 +29,14 @@ from ipor_fusion import (
     VaultValidation,
     Web3Context,
     validate_vault,
+    vault_data,
 )
 from ipor_fusion.cache import NullCache
 from ipor_fusion.core.oracle import price_oracle_middleware
 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 _derived_reads, _MarketReads
+from ipor_fusion.vault_data import VaultData, _MarketReads
 from ipor_fusion.vault_erc20 import _Asset, _erc20_holdings, _read_erc20_market
 
 
@@ -444,10 +444,12 @@ class TestReadErc20Holdings:
 
 
 class TestSnapshotTokenMetadata:
-    """`fetch_vault_data`'s ERC20 holdings and token metadata, from the
-    vault and market reads on."""
+    """`fetch_vault_data`'s optional token metadata. The vault, fee, queue,
+    role and market pipelines (the underlying asset's symbol and decimals
+    among them) are stubbed; the ERC20 market and the metadata batch run on
+    the fake chain, whose code reads raise."""
 
-    def _derive(self, *, metadata: bool) -> tuple[_Chain, dict[str, Any]]:
+    def _fetch(self, *, metadata: bool) -> tuple[_Chain, VaultData]:
         state = _erc20_state()
         chain = _Chain()
         ctx = Web3Context(chain.web3(), ChainId(1), cache=NullCache())
@@ -459,44 +461,69 @@ class TestSnapshotTokenMetadata:
             market_balances=chain.market_balances,  # type: ignore[arg-type]
         )
         vault_reads = {
+            "share_decimals": 18,
+            "total_assets": state.total_assets,
+            "total_supply": state.total_assets,
+            "supply_cap": state.total_assets,
             "asset": ASSET,
+            "access_manager": _addr("ac"),
+            "price_oracle": ORACLE,
+            "fuses": [FUSE],
+            "instant_fuses": [],
+            "vault_name": "Vault",
+            "rewards_manager": None,
             "asset_decimals": state.asset_decimals,
+            "underlying_balance_on_vault": state.underlying_balance_on_vault,
+            "asset_symbol": "USDC",
             "asset_price_usd": state.asset_price_usd,
+            "fuse_markets": None,
+            "unimplemented_getters": [],
         }
-        with ThreadPoolExecutor() as pool:
-            fields = _derived_reads(
+        oracle = price_oracle_middleware(ctx, ORACLE)  # type: ignore[arg-type]
+        with (
+            patch.object(vault_data, "_block_timestamp", return_value=1),
+            patch.object(
+                vault_data, "_fetch_vault_reads", return_value=(vault_reads, oracle)
+            ),
+            patch.object(vault_data, "_fetch_fee_data", return_value=None),
+            patch.object(
+                vault_data, "_fetch_withdraw_manager", return_value=(None, None)
+            ),
+            patch.object(vault_data, "_fetch_role_accounts", return_value=None),
+            patch.object(vault_data, "_fetch_market_reads", return_value=markets),
+            patch.object(vault_data, "_fetch_hypercore_state", return_value=None),
+        ):
+            data = vault_data.fetch_vault_data(
                 ctx,
-                pool,
                 VAULT,  # type: ignore[arg-type]
-                vault_reads,
-                price_oracle_middleware(ctx, ORACLE),  # type: ignore[arg-type]
-                markets,
-                None,
+                block=123,
+                lending=False,
                 metadata=metadata,
             )
-        return chain, fields
+        return chain, data
 
-    def test_without_metadata_no_symbol_is_read(self):
-        chain, fields = self._derive(metadata=False)
+    def test_without_metadata_no_token_symbol_is_read(self):
+        chain, data = self._fetch(metadata=False)
 
         assert chain.symbol_reads == 0
-        assert "token_symbols" not in fields
-        erc20 = fields["erc20"]
-        assert [t.symbol for t in erc20.tokens] == ["?", "?", "?"]
-        assert erc20.value_in_asset == 11 * WAD
+        assert (data.token_symbols, data.token_decimals) == ({}, {})
+        assert [t.symbol for t in data.erc20.tokens] == ["?", "?", "?"]
+        assert [t.decimals for t in data.erc20.tokens] == [18, 18, 18]
+        assert data.erc20.value_in_asset == 11 * WAD
+        assert data.asset_symbol == "USDC"
 
     def test_metadata_names_the_holdings_in_one_batch(self):
-        chain, fields = self._derive(metadata=True)
+        chain, data = self._fetch(metadata=True)
 
-        without, _ = self._derive(metadata=False)
+        without, _ = self._fetch(metadata=False)
         assert chain.symbol_reads == 3
         assert len(chain.blocks) == len(without.blocks) + 1
-        assert fields["token_symbols"] == {
+        assert data.token_symbols == {
             ASSET.lower(): "",
             TOKEN.lower(): "TKN",
             OTHER.lower(): "",
         }
-        assert [t.symbol for t in fields["erc20"].tokens] == ["?", "TKN", "?"]
+        assert [t.symbol for t in data.erc20.tokens] == ["?", "TKN", "?"]
 
 
 class TestValidateVault: