ipor-fusion 4.0.0.dev88__tar.gz → 4.0.0.dev93__tar.gz

{ipor_fusion-4.0.0.dev88 → ipor_fusion-4.0.0.dev93}/AGENTS.md

@@ -188,8 +188,9 @@ the lifecycle matrix follows that.
 - `substrates.py` — public per-market bytes32 substrate decoding (`decode_substrate`,
   `SubstrateInfo`, `format_market_label`, `market_name`; re-exported from `ipor_fusion`),
   used by the CLI, MCP and `readers/lending_health`
-- `validation.py` — public vault validation (`validate_vault`; `read_erc20_holdings` +
-  `validate_vault_state` for an already-fetched state typed by the `VaultState` protocol):
+- `validation.py` — public vault validation (`validate_vault` fetches and validates;
+  `validate_vault_state` is a pure function of a snapshot typed by the `VaultState`
+  protocol):
   `VaultValidation` with ordered `Finding`s, an ok/warning/critical verdict, the
   `Reconciliation`, `Erc20Holdings` and lending health; `dependency_graph.py` holds the
   balance-graph checks
@@ -197,9 +198,11 @@ the lifecycle matrix follows that.
   `WithdrawManagerData`), `fetch_deployment_info`, cached `resolve_token_symbol` /
   `resolve_token_decimals`; it composes `vault_reads.py` (the shared Multicall3 batch
   and degrade-to-``None`` helpers), `vault_managers.py` (fee and WithdrawManager
-  snapshots) and `vault_positions.py` (Morpho/Aave position breakdowns and their token
-  prices); `vault_info.py` — `build_vault_info_json`, the
-  `fusion vault info --json` document (contract names via an injected `resolve_name`),
+  snapshots), `vault_positions.py` (Morpho/Aave position breakdowns and their token
+  prices) and `vault_erc20.py` (the ERC20_VAULT_BALANCE holdings);
+  `vault_info.py` — `build_vault_info_json(data)`, the `fusion vault info --json`
+  document rendered from the snapshot alone (contract names via an injected
+  `resolve_name`),
   and `health_check_lists`; `explorer.py` Etherscan V2 (single endpoint, needs API key);
   `cache.py` the on-disk contract and deployment caches (`~/.cache/ipor-fusion/`).
   `morpho_api.py` the Morpho public GraphQL API client (`fetch_market`, `fetch_vault`,
@@ -295,6 +298,9 @@ or examples.
   via `self._action_raw(solidity_signature, values)`; the shared `_validate_*`
   helpers raise before encoding. `PlasmaVault.execute([actions])` runs the
   batch atomically.
+- Pin reads, never mutate a shared context: `ctx.at_block(n)` is a copy whose
+  reads (and `get_logs` upper bound) default to block ``n``; `Call.call(block=n)`
+  pins one read.
 - Simulate before sending: `VaultSimulator(web3, vault=, alpha=)` batches
   `execute` and `observe` calls into one `eth_simulateV1` round trip, across
   blocks via `next_block`. Integration tests and examples use it instead of a
@@ -383,9 +389,14 @@ are not validated.
 
 ## Domain rules (verified against the contracts)
 
-- `fetch_vault_data(..., chain_id=0)` (the default) skips lending_health,
-  Morpho/Aave position breakdowns and token prices, all guarded by `if chain_id:`.
-  Pass a real chain_id or those come back null/empty, silently.
+- `fetch_vault_data(ctx, vault, *, block=, lending=, metadata=)` is the snapshot:
+  it resolves one block (``block``, else a numeric `ctx.default_block`, else latest),
+  runs every read on `ctx.at_block(block)` (log scans end there too) and returns
+  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``
+  skips token symbols/decimals. 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
   view functions such as `getDependencyBalanceGraph`. An empty dependency graph

{ipor_fusion-4.0.0.dev88 → ipor_fusion-4.0.0.dev93}/MIGRATION_4.md

@@ -57,20 +57,40 @@ names earlier reachable only by module path (`FusionFactory`, `FusionInstance`,
 `ipor_fusion`: a module path outside the README's list (*Public API and stability*)
 still works but is internal.
 
-**Vault reads and validation.** `fetch_vault_data(chain_id=)`, `fetch_deployment_info`,
-`build_vault_info_json`, `ensure_supported_chain` and `fetch_vault_lending_health`
-take `ChainId`. The vault is a `PlasmaVaultAddress` (see *Address roles*) in
-`validate_vault` and `fetch_deployment_info`; `build_vault_info_json(ctx, plasma_vault,
-data, *, chain_id, chain_label)` takes no address, takes the chain by keyword, and
-labels the document with `plasma_vault.address` (a test that mocks `PlasmaVault`
-sets `.address`). `fetch_unpriceable_priced_tokens` takes the oracle and
+**Vault reads and validation.** The vault read is one pinned snapshot, and the
+chain is always the context's:
+
+- `fetch_vault_data(ctx, vault, *, block=None, lending=True, metadata=True)` takes
+  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`` skips token symbols
+  and decimals. `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)` fetches with ``metadata=False`` and
+  validates; it no longer takes ``resolve_symbol``. `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:
+  the holdings are `VaultData.erc20`.
+- `build_vault_info_json(data, *, resolve_name=None)` renders from the snapshot and
+  reads nothing; the chain and its label come from `data.chain_id`.
+- `fetch_deployment_info(ctx, vault, *, api_key=None)` and
+  `fetch_vault_lending_health(ctx, vault, *, balance_fuse_market_ids,
+  market_substrates, aave_pools=None)` take the chain from `ctx`.
+- `Web3Context(web3, chain_id, *, ...)` and `Web3Context.from_url(url, *, ...)` take
+  their options by keyword. New: `Web3Context.at_block(block)` (a pinned copy) and
+  `Call.call(ctx=None, *, block=None)`. `Web3Context.get_logs(to_block=None)` ends at
+  the context's default block and `Web3Context.get_block(block=None)` returns it,
+  both instead of ``"latest"``.
+
+`ensure_supported_chain` takes `ChainId`. `fetch_unpriceable_priced_tokens` takes the oracle and
 underlying as `ChecksumAddress`. `resolve_token_symbol`, `resolve_token_decimals`,
 `get_contract_name` and `get_deployment_tx` take `HexAddress` (a checksum address
 fits), and the `resolve_name` / `resolve_symbol` callbacks receive one (a callback
 typed for `str` still fits). Market-keyed data is keyed by `MarketId`:
 `VaultData.market_substrates`, `dependency_graph`, `morpho_positions`,
-`aave_positions`; the `VaultState` protocol, `validate_vault_state`
-(`market_balances`), `fetch_vault_lending_health`, `fetch_unpriceable_priced_tokens`
+`aave_positions`, `market_balances`; the `VaultState` protocol, `fetch_vault_lending_health`, `fetch_unpriceable_priced_tokens`
 and the `dependency_graph` helpers (`compute_update_reach`, `compute_update_groups`,
 `find_orphan_fuse_markets`, `find_markets_missing_erc20_dependency`).
 

{ipor_fusion-4.0.0.dev88 → ipor_fusion-4.0.0.dev93}/PKG-INFO

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

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

{ipor_fusion-4.0.0.dev88 → ipor_fusion-4.0.0.dev93}/src/ipor_fusion/__init__.py

@@ -445,7 +445,6 @@ from ipor_fusion.validation import (
     VaultState,
     VaultValidation,
     WithdrawQueue,
-    read_erc20_holdings,
     validate_vault,
     validate_vault_state,
 )
@@ -861,7 +860,6 @@ __all__ = [
     "VaultState",
     "VaultValidation",
     "WithdrawQueue",
-    "read_erc20_holdings",
     "validate_vault",
     "validate_vault_state",
     "compute_update_groups",

{ipor_fusion-4.0.0.dev88 → ipor_fusion-4.0.0.dev93}/src/ipor_fusion/cli/vault_cmd.py

@@ -2,7 +2,6 @@ from __future__ import annotations
 
 import json
 import sys
-from functools import partial
 from typing import Any
 
 import click
@@ -50,7 +49,6 @@ from ipor_fusion.validation import (
 from ipor_fusion.vault_data import (
     _ROLE_SCAN_ERRORS,
     fetch_vault_data,
-    resolve_token_symbol,
 )
 from ipor_fusion.vault_info import (
     _erc20_balances_json,
@@ -207,7 +205,6 @@ def info(
     """
     cfg = load_config()
     chain_id, ctx = _build_ctx(cfg, vault_address, chain_id, block_number)
-    checksum_address = vault_address
 
     # Cheap single-call probe: friendly errors for "nothing deployed here" and
     # "not a Plasma Vault" (revert and empty-return flavors alike) before the
@@ -217,17 +214,13 @@ def info(
     except (ContractNotFoundError, NotPlasmaVaultError) as exc:
         raise click.UsageError(str(exc)) from exc
 
-    plasma_vault = PlasmaVault(ctx, checksum_address)
-
-    _auto_save_vault(cfg, vault_address, chain_id, plasma_vault)
+    _auto_save_vault(cfg, vault_address, chain_id, PlasmaVault(ctx, vault_address))
 
     try:
-        data = fetch_vault_data(ctx, plasma_vault, block_number, chain_id=chain_id)
+        data = fetch_vault_data(ctx, vault_address, block=block_number)
     except UnsupportedVaultVersionError as exc:
         raise click.ClickException(str(exc)) from exc
-    _print_vault_info(
-        ctx, plasma_vault, cfg, data, vault_address, chain_id, json_output
-    )
+    _print_vault_info(ctx, cfg, data, json_output)
 
 
 @vault.command("validate")
@@ -264,12 +257,7 @@ def validate(
         raise click.UsageError(str(exc)) from exc
 
     try:
-        validation = validate_vault(
-            ctx,
-            vault_address,
-            block_number,
-            resolve_symbol=partial(resolve_token_symbol, ctx),
-        )
+        validation = validate_vault(ctx, vault_address, block=block_number)
     except UnsupportedVaultVersionError as exc:
         raise click.ClickException(str(exc)) from exc
 

{ipor_fusion-4.0.0.dev88 → ipor_fusion-4.0.0.dev93}/src/ipor_fusion/cli/vault_health.py

@@ -3,32 +3,18 @@
 
 from __future__ import annotations
 
-from functools import partial
-
 import click
 
 from ipor_fusion.cli.vault_rendering import _format_amount, _format_usd, _print_table
-from ipor_fusion.core.context import Web3Context
-from ipor_fusion.core.plasma_vault import PlasmaVault
 from ipor_fusion.substrates import market_name
 from ipor_fusion.validation import (
     Erc20Holdings,
     VaultValidation,
-    read_erc20_holdings,
 )
-from ipor_fusion.vault_data import VaultData, resolve_token_symbol
+from ipor_fusion.vault_data import VaultData
 from ipor_fusion.vault_info import health_check_lists
 
 
-def _read_erc20_holdings(
-    ctx: Web3Context, plasma_vault: PlasmaVault, data: VaultData
-) -> Erc20Holdings:
-    """ERC20 holdings with token symbols from the CLI's contract cache."""
-    return read_erc20_holdings(
-        ctx, plasma_vault, data, partial(resolve_token_symbol, ctx)
-    )
-
-
 def _print_erc20_balances(data: VaultData, erc20: Erc20Holdings) -> None:
     if not erc20.tokens:
         has_erc20_market = any(

{ipor_fusion-4.0.0.dev88 → ipor_fusion-4.0.0.dev93}/src/ipor_fusion/cli/vault_info_view.py

@@ -14,7 +14,6 @@ from ipor_fusion.cli.vault_health import (
     _print_erc20_balances,
     _print_health_check,
     _print_reconciliation,
-    _read_erc20_holdings,
 )
 from ipor_fusion.cli.vault_markets_view import _print_lending_health, _print_markets
 from ipor_fusion.cli.vault_rendering import (
@@ -26,7 +25,6 @@ from ipor_fusion.cli.vault_rendering import (
 )
 from ipor_fusion.core.context import Web3Context
 from ipor_fusion.core.fee_manager import RecipientFee
-from ipor_fusion.core.plasma_vault import PlasmaVault
 from ipor_fusion.explorer import get_contract_name
 from ipor_fusion.readers.hypercore import HyperCorePendingState
 from ipor_fusion.substrates import (
@@ -48,7 +46,6 @@ from ipor_fusion.vault_info import (
     _wad_to_usd,
     build_vault_info_json,
 )
-from ipor_fusion.vault_reads import _safe_call
 
 
 def _print_role_accounts_table(role_accounts: list[dict[str, Any]]) -> None:
@@ -76,38 +73,28 @@ def _print_role_accounts(role_accounts: list[dict[str, Any]] | None) -> None:
 
 
 def _print_vault_info(
-    ctx: Web3Context,
-    plasma_vault: PlasmaVault,
-    cfg: FusionConfig,
-    data: VaultData,
-    vault_address: PlasmaVaultAddress,
-    chain_id: ChainId,
-    json_output: bool = False,
+    ctx: Web3Context, cfg: FusionConfig, data: VaultData, json_output: bool = False
 ) -> None:
     api_key = cfg.etherscan_api_key
+    chain_id = data.chain_id
     chain_label = CHAIN_NAMES.get(chain_id, str(chain_id))
 
     (
         data.deployment_block,
         data.deployment_timestamp,
         data.deployment_error,
-    ) = fetch_deployment_info(ctx, chain_id, vault_address, api_key)
+    ) = fetch_deployment_info(ctx, data.vault, api_key=api_key)
 
     if json_output:
         result = build_vault_info_json(
-            ctx,
-            plasma_vault,
-            data,
-            chain_id=chain_id,
-            chain_label=chain_label,
-            resolve_name=partial(get_contract_name, chain_id, api_key=api_key),
+            data, resolve_name=partial(get_contract_name, chain_id, api_key=api_key)
         )
         click.echo(json.dumps(result, indent=2))
         return
 
-    _print_identity(data, vault_address, chain_id, chain_label)
+    _print_identity(data, data.vault, chain_id, chain_label)
     _print_supply(data)
-    _print_managers(data, plasma_vault)
+    _print_managers(data)
     click.echo()
 
     _print_fees(data)
@@ -115,15 +102,9 @@ def _print_vault_info(
 
     _print_role_accounts(_role_accounts_json(data))
 
-    market_balances = _print_markets(ctx, plasma_vault, data, chain_id, api_key)
+    _print_markets(data, api_key)
 
-    validation = validate_vault_state(
-        ctx,
-        plasma_vault,
-        data,
-        market_balances,
-        _read_erc20_holdings(ctx, plasma_vault, data),
-    )
+    validation = validate_vault_state(data)
     click.echo("ERC20 Balances (vault holdings):")
     _print_erc20_balances(data, validation.erc20)
     click.echo()
@@ -131,7 +112,7 @@ def _print_vault_info(
     _print_reconciliation(data, validation)
     click.echo()
 
-    _print_lending_health(ctx, data)
+    _print_lending_health(data)
     click.echo()
     _print_hypercore(data)
 
@@ -207,7 +188,7 @@ def _print_supply(data: VaultData) -> None:
         )
 
 
-def _print_managers(data: VaultData, plasma_vault: PlasmaVault) -> None:
+def _print_managers(data: VaultData) -> None:
     click.echo(f"Access Manager:   {data.access_manager}")
     click.echo(f"Price Oracle:     {data.price_oracle_addr}")
     click.echo(f"Rewards Manager:  {data.rewards_manager or 'N/A'}")
@@ -222,7 +203,7 @@ def _print_managers(data: VaultData, plasma_vault: PlasmaVault) -> None:
         if wmd.last_release_funds_timestamp > 0:
             last_iso = _unix_to_iso(wmd.last_release_funds_timestamp)
             click.echo(f"  Last release:   {last_iso}")
-        _print_pending_requests(data, plasma_vault)
+        _print_pending_requests(data)
 
 
 def _format_fee_percent(value: float | None) -> str:
@@ -375,7 +356,7 @@ def _print_hypercore_pending(pending: HyperCorePendingState | None) -> None:
         )
 
 
-def _print_pending_requests(data: VaultData, plasma_vault: PlasmaVault) -> None:
+def _print_pending_requests(data: VaultData) -> None:
     if (wmd := data.withdraw_manager_data) is None:
         return
     if wmd.pending_requests is None:
@@ -389,16 +370,14 @@ def _print_pending_requests(data: VaultData, plasma_vault: PlasmaVault) -> None:
         return
 
     total_shares = Shares(sum(r.shares for r in requests))
-    total_assets: int | None = _safe_call(
-        lambda ts=total_shares: plasma_vault.convert_to_assets(ts).call()
+    request_assets = [wmd.pending_request_assets.get(r.account) for r in requests]
+    total_assets = (
+        None if None in request_assets else sum(a for a in request_assets if a)
     )
 
     click.echo(f"  Pending requests ({len(requests)}):")
     rows: list[tuple[str, ...]] = []
-    for req in requests:
-        assets: int | None = _safe_call(
-            lambda s=req.shares: plasma_vault.convert_to_assets(s).call()
-        )
+    for req, assets in zip(requests, request_assets, strict=True):
         assets_str = (
             f"{_format_amount(assets, data.asset_decimals)} {data.asset_symbol}"
             if assets is not None

{ipor_fusion-4.0.0.dev88 → ipor_fusion-4.0.0.dev93}/src/ipor_fusion/cli/vault_markets_view.py

@@ -13,8 +13,6 @@ from ipor_fusion.cli.vault_rendering import (
     _print_table,
     _substrate_details,
 )
-from ipor_fusion.core.context import Web3Context
-from ipor_fusion.core.plasma_vault import BalanceFuse, PlasmaVault
 from ipor_fusion.explorer import get_contract_name
 from ipor_fusion.substrates import (
     decode_substrate,
@@ -24,17 +22,13 @@ from ipor_fusion.types import ChainId, FuseAddress, MarketId, parse_hex_address
 from ipor_fusion.vault_data import (
     GET_MARKET_SUBSTRATES,
     VaultData,
-    resolve_token_decimals,
-    resolve_token_symbol,
 )
 from ipor_fusion.vault_info import (
     _CAPABILITY_BALANCE_FUSES,
 )
 
 
-def _print_lending_health(  # noqa: C901
-    ctx: Web3Context, data: VaultData
-) -> None:
+def _print_lending_health(data: VaultData) -> None:  # noqa: C901
     lh = data.lending_health
     has_health = lh is not None and lh.has_lending_positions
     has_breakdown = bool(data.morpho_positions) or bool(data.aave_positions)
@@ -46,22 +40,21 @@ def _print_lending_health(  # noqa: C901
     morpho_health, aave_health = _index_lending_health(lh)
     consumed_morpho_subs: set[str] = set()
     consumed_aave_mids: set[int | str] = set()
-    prices = data.token_prices_usd or {}
 
     for ipor_mid, positions in (data.morpho_positions or {}).items():
         click.echo(f"  {format_market_label(ipor_mid)}:")
         for pb in positions:
-            coll_sym = resolve_token_symbol(ctx, pb.collateral_token) or "?"
-            loan_sym = resolve_token_symbol(ctx, pb.loan_token) or "?"
+            coll_sym = _token_symbol(data, pb.collateral_token)
+            loan_sym = _token_symbol(data, pb.loan_token)
             click.echo(f"    morpho market {pb.market_id} ({coll_sym}/{loan_sym}):")
             click.echo(
-                f"      Collateral:    {_format_token_amount(ctx, int(pb.collateral), pb.collateral_token, prices)}"
+                f"      Collateral:    {_format_token_amount(data, int(pb.collateral), pb.collateral_token)}"
             )
             click.echo(
-                f"      Borrow:        {_format_token_amount(ctx, int(pb.borrow_assets), pb.loan_token, prices)}"
+                f"      Borrow:        {_format_token_amount(data, int(pb.borrow_assets), pb.loan_token)}"
             )
             click.echo(
-                f"      Supply:        {_format_token_amount(ctx, int(pb.supply_assets), pb.loan_token, prices)}"
+                f"      Supply:        {_format_token_amount(data, int(pb.supply_assets), pb.loan_token)}"
             )
             sid = str(pb.market_id).lower().removeprefix("0x")
             consumed_morpho_subs.add(sid)
@@ -71,17 +64,17 @@ def _print_lending_health(  # noqa: C901
     for ipor_mid, aave_positions in (data.aave_positions or {}).items():
         click.echo(f"  {format_market_label(ipor_mid)}:")
         for ab in aave_positions:
-            asset_symbol = resolve_token_symbol(ctx, ab.asset) or "?"
+            asset_symbol = _token_symbol(data, ab.asset)
             click.echo(f"    asset {ab.asset} ({asset_symbol}):")
             click.echo(
-                f"      Supply:        {_format_token_amount(ctx, int(ab.supply), ab.asset, prices)}"
+                f"      Supply:        {_format_token_amount(data, int(ab.supply), ab.asset)}"
             )
             click.echo(
-                f"      Variable Debt: {_format_token_amount(ctx, int(ab.variable_debt), ab.asset, prices)}"
+                f"      Variable Debt: {_format_token_amount(data, int(ab.variable_debt), ab.asset)}"
             )
             if ab.stable_debt > 0:
                 click.echo(
-                    f"      Stable Debt:   {_format_token_amount(ctx, int(ab.stable_debt), ab.asset, prices)}"
+                    f"      Stable Debt:   {_format_token_amount(data, int(ab.stable_debt), ab.asset)}"
                 )
         consumed_aave_mids.add(ipor_mid)
         if m := aave_health.get(ipor_mid):
@@ -161,15 +154,9 @@ def _print_health_lines(market: Any, indent: str) -> None:
     click.secho(f"{indent}Status:        {status}", fg=color, bold=bold)
 
 
-def _print_markets(
-    ctx: Web3Context,
-    plasma_vault: PlasmaVault,
-    data: VaultData,
-    chain_id: ChainId,
-    api_key: str | None,
-) -> dict[MarketId, int]:
-    """Fuses, balance fuses, dependency graph and substrates; returns the
-    per-market balances read for the balance-fuse table."""
+def _print_markets(data: VaultData, api_key: str | None) -> None:
+    """Fuses, balance fuses, dependency graph and substrates."""
+    chain_id = data.chain_id
     _print_fuse_section(
         "Fuses",
         data.fuses,
@@ -190,46 +177,31 @@ def _print_markets(
     )
     click.echo()
 
-    market_balances = _print_balance_fuses_table(
-        plasma_vault,
-        data.balance_fuses,
-        data.asset_decimals,
-        data.asset_symbol,
-        data.asset_price_usd,
-        chain_id,
-        api_key,
-    )
+    _print_balance_fuses_table(data, api_key)
     click.echo()
 
     _print_dependency_graph(data)
 
     click.echo("Substrates per Market:")
-    _print_market_substrates(ctx, data, chain_id, api_key)
+    _print_market_substrates(data, api_key)
     click.echo()
-    return market_balances
 
 
-def _format_token_amount(
-    ctx: Web3Context,
-    raw: int,
-    token_address: HexAddress,
-    prices_usd: dict[HexAddress, float] | None = None,
-) -> str:
-    """Format a raw on-chain amount using cached ERC-20 symbol + decimals.
+def _token_symbol(data: VaultData, token_address: HexAddress) -> str:
+    return data.token_symbols.get(parse_hex_address(token_address)) or "?"
 
-    When `prices_usd` (lowercase address → USD price) contains the token, the
-    output is suffixed with ` ($X.XX)` via `_format_usd`.
-    """
-    symbol = resolve_token_symbol(ctx, token_address) or "?"
-    decimals = resolve_token_decimals(ctx, token_address)
+
+def _format_token_amount(data: VaultData, raw: int, token_address: HexAddress) -> str:
+    """Format a raw amount with the snapshot's symbol and decimals, suffixed
+    with ` ($X.XX)` when the snapshot has the token's USD price."""
+    key = parse_hex_address(token_address)
+    symbol = data.token_symbols.get(key) or "?"
+    decimals = data.token_decimals.get(key)
     if decimals is None:
         return f"{raw} raw ({symbol})"
     base = f"{_format_amount(raw, decimals)} {symbol}"
-    if prices_usd:
-        usd_suffix = _format_usd(
-            raw, decimals, prices_usd.get(parse_hex_address(token_address))
-        )
-        return f"{base}{usd_suffix}"
+    if prices_usd := data.token_prices_usd:
+        return f"{base}{_format_usd(raw, decimals, prices_usd.get(key))}"
     return base
 
 
@@ -313,37 +285,24 @@ def _print_fuse_section(
     _print_table(("#", "Address", "Contract", "Market", "Substrates"), rows)
 
 
-def _print_balance_fuses_table(
-    plasma_vault: PlasmaVault,
-    balance_fuses: Sequence[BalanceFuse],
-    decimals: int,
-    asset_symbol: str,
-    asset_price_usd: float | None,
-    chain_id: ChainId,
-    api_key: str | None,
-) -> dict[MarketId, int]:
-    """Print the table; return each market's cached balance, once per market
-    (several balance fuses can share a market's single storage slot)."""
-    market_balances: dict[MarketId, int] = {}
+def _print_balance_fuses_table(data: VaultData, api_key: str | None) -> None:
+    balance_fuses = data.balance_fuses
+    decimals = data.asset_decimals
+    asset_symbol = data.asset_symbol
+    asset_price_usd = data.asset_price_usd
     with ThreadPoolExecutor() as pool:
-        futures: list[tuple[int, MarketId, str, Future, Future]] = []
+        futures: list[tuple[int, MarketId, str, Future]] = []
         for idx, balance_fuse in enumerate(balance_fuses, 1):
             market_id_str = format_market_label(balance_fuse.market_id)
-            f_balance = pool.submit(
-                plasma_vault.total_assets_in_market(balance_fuse.market_id).call
-            )
             f_contract = pool.submit(
-                get_contract_name, chain_id, balance_fuse.fuse, api_key
-            )
-            futures.append(
-                (idx, balance_fuse.market_id, market_id_str, f_balance, f_contract)
+                get_contract_name, data.chain_id, balance_fuse.fuse, api_key
             )
+            futures.append((idx, balance_fuse.market_id, market_id_str, f_contract))
 
         venue_rows: list[tuple[str, ...]] = []
         zero_rows: list[tuple[str, ...]] = []
-        for idx, market_id, market_id_str, f_balance, f_contract in futures:
-            assets_in_market = f_balance.result()
-            market_balances.setdefault(market_id, assets_in_market)
+        for idx, market_id, market_id_str, f_contract in futures:
+            assets_in_market = data.market_balances[market_id]
             contract_name = f_contract.result() or "?"
             balance_str = (
                 f"{_format_amount(assets_in_market, decimals)} {asset_symbol}"
@@ -367,30 +326,23 @@ def _print_balance_fuses_table(
         click.echo()
         click.echo(f"Zero-Balance Fuses ({len(zero_rows)}):")
         _print_table(header, [(str(i), *row) for i, row in enumerate(zero_rows, 1)])
-    return market_balances
 
 
-def _print_market_substrates(
-    ctx: Web3Context, data: VaultData, chain_id: ChainId, api_key: str | None
-) -> set[str]:
+def _print_market_substrates(data: VaultData, api_key: str | None) -> set[str]:
     if GET_MARKET_SUBSTRATES in data.unimplemented_getters:
         click.secho(
             f"  (unavailable: the vault predates {GET_MARKET_SUBSTRATES})",
             fg="yellow",
         )
         return set()
-    return _print_substrates(
-        ctx, data.market_substrates or {}, data.balance_fuses, chain_id, api_key
-    )
+    return _print_substrates(data, api_key)
 
 
 def _print_substrates(  # noqa: C901
-    ctx: Web3Context,
-    substrates_by_market: dict[MarketId, list[bytes]],
-    balance_fuses: Sequence[BalanceFuse],
-    chain_id: ChainId,
-    api_key: str | None,
+    data: VaultData, api_key: str | None
 ) -> set[str]:
+    substrates_by_market = data.market_substrates or {}
+    balance_fuses = data.balance_fuses
     # Phase 1: collect each balance fuse's substrates and the addresses to resolve
     market_substrates: list[tuple[str, MarketId, list[bytes]]] = []
     all_addresses: set[HexAddress] = set()
@@ -408,17 +360,13 @@ def _print_substrates(  # noqa: C901
         click.echo("  (none)")
         return {a.lower() for a in all_addresses}
 
-    # Phase 2: resolve all symbols + contract names in parallel
+    # Phase 2: resolve contract names in parallel; symbols are in the snapshot
+    resolved_symbols = data.token_symbols
     with ThreadPoolExecutor() as pool:
-        symbol_futs = {
-            addr: pool.submit(resolve_token_symbol, ctx, addr) for addr in all_addresses
-        }
         contract_futs = {
-            addr: pool.submit(get_contract_name, chain_id, addr, api_key)
+            addr: pool.submit(get_contract_name, data.chain_id, addr, api_key)
             for addr in all_addresses
         }
-
-        resolved_symbols = {addr: fut.result() for addr, fut in symbol_futs.items()}
         resolved_contracts = {addr: fut.result() for addr, fut in contract_futs.items()}
 
     # Phase 3: print