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

{ipor_fusion-4.0.0.dev86 → 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`,
@@ -218,12 +221,14 @@ the lifecycle matrix follows that.
   `simulation` (`VaultSimulator`, eth_simulateV1, `erc20_balance_slot` and ERC-20 balance
   overrides), `oracle`, `fusion_factory`,
   `external_state_executor` (NAV marks for market 50), `erc20`, `fuse_action`
-  (`FuseAction`), `address` (`_validate_not_zero_address`). `core` imports neither
+  (`FuseAction`), `fuse` (the `Fuse` base, `StakeFuse`, the shared validators and
+  substrate packers), `address` (`_validate_not_zero_address`). `core` imports neither
   `fuses` nor `crosschain` (`tests/test_sdk_layering.py`)
 - `fuses/` — per-protocol fuse encoders (aave_v3, async_action, compound_v3, crosschain/,
   erc4626, euler_v2, external_state, fluid_instadapp, gearbox_v3, merkl, morpho, ramses_v2,
-  uniswap_v3, universal, `events.py`); `base.py` holds `Fuse` and the
-  shared validators and re-exports `FuseAction` and `ZERO_ADDRESS` (from `types`)
+  uniswap_v3, universal, `events.py`); `base.py` re-exports the `core/fuse.py` base and validators,
+  `FuseAction` and `ZERO_ADDRESS` (from `types`). A fuse is a value: equality and
+  hash cover its class and every attribute it stores
 - `crosschain/` — crosschain Plasma Vaults (executor on the hub chain, dispatcher at
   the same address on each spoke chain), split like the contracts: shared `messages`
   (`Command`, `MsgType`, envelopes), `contracts` (wrapper bases), `transport`
@@ -276,7 +281,9 @@ or examples.
 - `Call[T]` (`core/contract.py`): every `ContractWrapper` method (one per
   Solidity function) returns a `Call` instead of executing. `.call()` runs
   `eth_call` and decodes to `T`; `.send()` signs and submits, returning a
-  `TxReceipt`; `.calldata` hands the bytes to an external signer;
+  `TxReceipt`; `.calldata` hands the bytes to an external signer (a wrapper
+  built with `ctx=None`, e.g. `PlasmaVault(None, address)`, builds calldata
+  offline; there is no separate encoder factory);
   `.build_transaction()` / `Web3Context.estimate_gas` preview without signing.
   A `Call` without `output_types` (a write) raises on `.call()`. The same
   `Call` feeds `VaultSimulator.observe`, so reads, sends and simulations share
@@ -291,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
@@ -379,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.dev86 → 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`).
 
@@ -93,7 +113,7 @@ The Uniswap V3 / Ramses V2 position events' `version`, `sender` and `recipient`
 `quote_ccip_native_fee(block=)` and `OracleMappingReader.asset_source_events` take a
 `BlockIdentifier`.
 
-**Address roles.** `PlasmaVault(ctx, address)`, `PlasmaVault.encoder(address)`,
+**Address roles.** `PlasmaVault(ctx, address)` (`ctx` may be `None`, see below),
 `validate_vault`, `fetch_deployment_info`, the HyperCore, lending-health and
 oracle-mapping readers, `read_external_state`, `VaultSimulator(vault=)`,
 `CrosschainSimulator`, crosschain discovery, the hub-manager inputs
@@ -194,6 +214,35 @@ are `ProposalHash`; `ExternalStateEvent.transaction_hash` is a `TxHash`.
 except below): `chain_id` fields are `ChainId`, `role_id` `RoleId`, `market_id`
 `MarketId`. Calling an MCP tool function directly from Python takes `ChainId`.
 
+**Offline wrappers.** `ContractWrapper.encoder()` (and the `PlasmaVault` /
+`AccessManager` overrides) is gone. Every wrapper constructor takes
+`ctx: Web3Context | None`, so build an offline wrapper with the normal
+constructor and an address: `PlasmaVault(None, vault)`, `ERC20(None, token)`,
+`FusionFactory(None, factory)`, `LegacyPriceOracleMiddleware(None, oracle,
+Decimals(8))`. The address is required (there is no zero-address placeholder) and
+subclass parameters stay required, so the wrapper is fully initialized:
+`.encoder()` skipped the constructor, and a legacy oracle built that way failed to
+decode `get_asset_price`. `.calldata` still needs no context; `.call()`, `.send()`,
+`.build_transaction()` and `.estimate_gas()` raise `ValueError` until one is passed
+to them, and a method that reads the chain itself (log scans such as
+`get_balance_fuses` or `get_pending_requests`, `withdraw_manager_address`,
+`Multicall3.aggregate` / `try_aggregate`, the Aave V3 and Morpho position reads)
+raises `ValueError("Web3Context required: <wrapper> at <address> ...")` instead of
+an `AttributeError` on `None`. `ExternalStateExecutor` still refuses the zero
+address for its hash and event readers.
+
+| 3.x | 4.0 |
+|---|---|
+| `PlasmaVault.encoder(vault)` | `PlasmaVault(None, vault)` |
+| `ERC20.encoder()` (no address) | `ERC20(None, token)`: pass the real address |
+| `Cls.__new__(Cls)` + `_ctx` / `_address` | `Cls(None, address)` |
+
+**Fuse base.** `Fuse`, `StakeFuse` and the shared validators and substrate packers
+live in `ipor_fusion.core.fuse`; `ipor_fusion.fuses.base`, `ipor_fusion.fuses` and
+`ipor_fusion` re-export them, so existing imports keep working. Fuse equality and
+hash now cover every attribute a fuse stores, not only its class and address (see
+[Behavior changes](#behavior-changes)).
+
 **Moved, still importable.** `FuseAction` lives in `ipor_fusion.core.fuse_action` and
 `ZERO_ADDRESS` in `ipor_fusion.types`; both are re-exported from
 `ipor_fusion.fuses.base` and `FuseAction` from `ipor_fusion`. The CLI's internal
@@ -202,6 +251,12 @@ except below): `chain_id` fields are `ChainId`, `role_id` `RoleId`, `market_id`
 
 ## Behavior changes
 
+- Two fuses are equal (and hash alike) only when they have the same class and the
+  same stored state. `StakeFuse` subclasses (`GearboxStakeFuse`,
+  `FluidInstadappStakingFuse`) with the same fuse address but different
+  `staking_address` were equal and collapsed in a set or dict key; they are now
+  distinct. A custom `Fuse` subclass is compared on its instance attributes, which
+  must be hashable; drop an `__eq__` / `__hash__` override that only added them.
 - The MCP `vault_info` document reports the vault address checksummed (the CLI
   already did).
 - `SubstrateInfo.address` is `None` instead of `""` for a substrate without an

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: ipor-fusion
-Version: 4.0.0.dev86
+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.dev86 → ipor_fusion-4.0.0.dev93}/examples/advanced_euler_v2_credit_market_base.py

@@ -261,12 +261,12 @@ def clone_args() -> dict:
 def unsigned_clone_calldata() -> bytes:
     """Unsigned creation calldata (selector + ABI-encoded args) for the deploy.
 
-    Built with a ctx-less encoder, so it needs no provider. Hand these bytes to
+    Built on a wrapper with ctx=None, so it needs no provider. Hand these bytes to
     an external signer / multisig instead of calling ``.send()``. NOTE: the owner
     encoded here is the simulation ``OWNER`` (a throwaway EOA) -- set your real
     owner in ``clone_args()`` before deploying, or the vault is owned by it.
     """
-    return FusionFactory.encoder(BASE_FUSION_FACTORY).clone(**clone_args()).calldata
+    return FusionFactory(None, BASE_FUSION_FACTORY).clone(**clone_args()).calldata
 
 
 def market_substrates() -> list[bytes]:

{ipor_fusion-4.0.0.dev86 → ipor_fusion-4.0.0.dev93}/examples/advanced_euler_v2_looping_arbitrum.py

@@ -208,7 +208,7 @@ def clone_args() -> dict:
 
 
 def unsigned_clone_calldata() -> bytes:
-    return FusionFactory.encoder(ARBITRUM_FUSION_FACTORY).clone(**clone_args()).calldata
+    return FusionFactory(None, ARBITRUM_FUSION_FACTORY).clone(**clone_args()).calldata
 
 
 def euler_market_substrates() -> list[bytes]:
@@ -260,7 +260,7 @@ def enable_euler_actions() -> list[FuseAction]:
 def build_swap_action() -> FuseAction:
     """Swap the borrowed USDC through Uniswap V3 and require flash repayment."""
     transfer_data = (
-        ERC20.encoder(ARBITRUM_USDC)
+        ERC20(None, ARBITRUM_USDC)
         .transfer(UNISWAP_UNIVERSAL_ROUTER, BORROW_USDC)
         .calldata
     )

{ipor_fusion-4.0.0.dev86 → ipor_fusion-4.0.0.dev93}/examples/external_state_margin_leg_base.py

@@ -438,12 +438,12 @@ def clone_args() -> dict:
 def unsigned_clone_calldata() -> bytes:
     """Unsigned creation calldata (selector + ABI-encoded args) for the deploy.
 
-    Built with a ctx-less encoder, so it needs no provider. Hand these bytes to
+    Built on a wrapper with ctx=None, so it needs no provider. Hand these bytes to
     an external signer / multisig instead of calling ``.send()``. NOTE: the owner
     encoded here is the simulation ``OWNER`` (a throwaway EOA) -- set your real
     owner in ``clone_args()`` before deploying, or the vault is owned by it.
     """
-    return FusionFactory.encoder(BASE_FUSION_FACTORY).clone(**clone_args()).calldata
+    return FusionFactory(None, BASE_FUSION_FACTORY).clone(**clone_args()).calldata
 
 
 def market_substrates() -> list[bytes]:
@@ -534,9 +534,9 @@ def market_substrates() -> list[bytes]:
 def venue_transfer_calldata(amount: Amount) -> bytes:
     """``USDC.transfer(VENUE_DEPOSIT_ADDRESS, amount)`` calldata, run from the executor.
 
-    Encoded with a ctx-less ERC20 wrapper -- pure bytes, no chain access.
+    Encoded with an ERC20 wrapper built with ctx=None -- pure bytes, no chain access.
     """
-    return ERC20.encoder(BASE_USDC).transfer(VENUE_DEPOSIT_ADDRESS, amount).calldata
+    return ERC20(None, BASE_USDC).transfer(VENUE_DEPOSIT_ADDRESS, amount).calldata
 
 
 def build_enter_action(amount: Amount) -> FuseAction:

{ipor_fusion-4.0.0.dev86 → ipor_fusion-4.0.0.dev93}/examples/simple_aave_v3_supply_base.py

@@ -201,12 +201,12 @@ def clone_args() -> dict:
 def unsigned_clone_calldata() -> bytes:
     """Unsigned creation calldata (selector + ABI-encoded args) for the deploy.
 
-    Built with a ctx-less encoder, so it needs no provider. Hand these bytes to
+    Built on a wrapper with ctx=None, so it needs no provider. Hand these bytes to
     an external signer / multisig instead of calling ``.send()``. NOTE: the owner
     encoded here is the simulation ``OWNER`` (a throwaway EOA) -- set your real
     owner in ``clone_args()`` before deploying, or the vault is owned by it.
     """
-    return FusionFactory.encoder(BASE_FUSION_FACTORY).clone(**clone_args()).calldata
+    return FusionFactory(None, BASE_FUSION_FACTORY).clone(**clone_args()).calldata
 
 
 def build_supply_action(amount: Amount) -> FuseAction:

{ipor_fusion-4.0.0.dev86 → ipor_fusion-4.0.0.dev93}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "ipor-fusion"
-version = "4.0.0.dev86"
+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.dev86 → 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.dev86 → 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.dev86 → 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.dev86 → 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