ipor-fusion 4.0.0.dev108__tar.gz → 4.0.0.dev114__tar.gz

{ipor_fusion-4.0.0.dev108 → ipor_fusion-4.0.0.dev114}/AGENTS.md

@@ -158,7 +158,7 @@ the lifecycle matrix follows that.
   subpackage (`core`, `config`, `fuses`, `readers`, `crosschain`,
   `crosschain.fuses`, `crosschain.ccip`, `crosschain.stargate`) also goes in that
   subpackage's `__all__`. `ipor_fusion.guide` keeps its own namespace. The
-  public modules (`about`, `chains`, `dependency_graph`, `errors`, `explorer`,
+  public modules (`about`, `cache`, `chains`, `dependency_graph`, `errors`, `explorer`,
   `field_docs`, `market_ids`, `market_info`, `morpho_api`, `substrates`, `types`,
   `validation`, `vault_data`, `vault_info`) stay importable for the names they
   define; `cli`, `mcp` and every other module are internal. Examples, the guide

{ipor_fusion-4.0.0.dev108 → ipor_fusion-4.0.0.dev114}/MIGRATION_4.md

@@ -84,6 +84,20 @@ chain is always the context's:
   the context's default block and `Web3Context.get_block(block=None)` returns it,
   both instead of ``"latest"``.
 
+Snapshot fields carry their units: `VaultData.total_assets`,
+`underlying_balance_on_vault` and `market_balances` values are `Amount`;
+`total_supply` and `supply_cap` are `Shares`; `share_decimals` / `asset_decimals` are `Decimals`;
+`block_timestamp` and `deployment_timestamp` are `Timestamp`. `FeeData` fee fields
+are `Fee`, `management_fee_last_update` a `Timestamp`, `unrealized_management_fee` an
+`Amount`; `WithdrawManagerData.withdraw_window` is a `Period`, its fees `Fee`,
+`shares_to_release` `Shares`, `last_release_funds_timestamp` a `Timestamp` and the
+converted amounts `Amount`. A custom `VaultState` annotates the same.
+`PlasmaVault.total_supply()`, `balance_of()` and `get_total_supply_cap()` return
+`Shares` (vault shares), and `transfer` / `approve` / `transfer_from` /
+`set_total_supply_cap` take `Shares`; `ERC20` keeps `Amount`. The supply cap is
+now shown in share decimals labelled `shares` (``fusion vault info``) and its JSON
+``formatted`` uses `share_decimals`; it was formatted with the asset's decimals.
+
 `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
@@ -351,8 +365,12 @@ Contract names, token symbols and decimals and deployment blocks are cached in a
   (`fetch_vault_data(metadata=True)`) and `fetch_deployment_info` use `ctx.cache`.
   `get_contract_name(chain_id, address, api_key=None, *, cache=None)` takes the cache
   explicitly (default: the file cache); pass `cache=ctx.cache` to share the
-  context's policy. `build_vault_info_json` without `resolve_name` still names
-  contracts from the default file cache; pass `resolve_name` to avoid it.
+  context's policy. The CLI's text and JSON output name contracts through the
+  context's cache.
+- `build_vault_info_json(data)` without `resolve_name` names no contract (every
+  `contract` is `"?"`) instead of reading names from the on-disk cache; pass
+  `resolve_name=partial(get_contract_name, chain_id, api_key=..., cache=ctx.cache)`
+  for the CLI's document.
 - `ipor_fusion.cache` is a public module now and exports `ContractCache`,
   `FileContractCache`, `NullCache`, `CacheKey`, `CacheField`, `cache_key` and
   `default_contract_cache` (also from `ipor_fusion`). Its 3.x functions and constants
@@ -384,7 +402,8 @@ Etherscan key) and the old file can be deleted.
 - A cache never fails a read: a corrupt or unreadable file reads as empty (logged
   warning from `ipor_fusion.cache`) and is rewritten by the next write; an unwritable
   directory (read-only file system) keeps the entries in memory for the process; a
-  custom cache that raises is treated as a miss.
+  custom cache that raises is treated as a miss, and so is a stored number that does
+  not parse.
 - `fetch_deployment_info` returns `rpc-fetch-failed` only when the creation
   transaction or its block cannot be read; a cache failure is no longer reported as
   one (the deployment block is returned).

{ipor_fusion-4.0.0.dev108 → ipor_fusion-4.0.0.dev114}/PKG-INFO

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

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

{ipor_fusion-4.0.0.dev108 → ipor_fusion-4.0.0.dev114}/src/ipor_fusion/cli/vault_info_view.py

@@ -85,13 +85,11 @@ def _print_vault_info(
         data.deployment_error,
     ) = fetch_deployment_info(ctx, data.vault, api_key=api_key)
 
+    resolve_name = partial(
+        get_contract_name, chain_id, api_key=api_key, cache=ctx.cache
+    )
     if json_output:
-        result = build_vault_info_json(
-            data,
-            resolve_name=partial(
-                get_contract_name, chain_id, api_key=api_key, cache=ctx.cache
-            ),
-        )
+        result = build_vault_info_json(data, resolve_name=resolve_name)
         click.echo(json.dumps(result, indent=2))
         return
 
@@ -105,7 +103,7 @@ def _print_vault_info(
 
     _print_role_accounts(_role_accounts_json(data))
 
-    _print_markets(data, api_key)
+    _print_markets(data, resolve_name)
 
     validation = validate_vault_state(data)
     click.echo("ERC20 Balances (vault holdings):")
@@ -187,7 +185,7 @@ def _print_supply(data: VaultData) -> None:
     else:
         click.echo(
             f"Supply Cap:       "
-            f"{_format_amount(data.supply_cap, data.asset_decimals)} {data.asset_symbol}"
+            f"{_format_amount(data.supply_cap, data.share_decimals)} shares"
         )
 
 

{ipor_fusion-4.0.0.dev108 → ipor_fusion-4.0.0.dev114}/src/ipor_fusion/cli/vault_markets_view.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from collections.abc import Sequence
+from collections.abc import Callable, Sequence
 from concurrent.futures import Future, ThreadPoolExecutor
 from typing import Any
 
@@ -13,12 +13,11 @@ from ipor_fusion.cli.vault_rendering import (
     _print_table,
     _substrate_details,
 )
-from ipor_fusion.explorer import get_contract_name
 from ipor_fusion.substrates import (
     decode_substrate,
     format_market_label,
 )
-from ipor_fusion.types import ChainId, FuseAddress, MarketId, parse_hex_address
+from ipor_fusion.types import FuseAddress, MarketId, parse_hex_address
 from ipor_fusion.vault_data import (
     GET_MARKET_SUBSTRATES,
     VaultData,
@@ -27,6 +26,10 @@ from ipor_fusion.vault_info import (
     _CAPABILITY_BALANCE_FUSES,
 )
 
+# Address to contract name, "" when unknown (`get_contract_name` bound to the
+# chain, API key and the context's cache).
+NameResolver = Callable[[HexAddress], str]
+
 
 def _print_lending_health(data: VaultData) -> None:  # noqa: C901
     lh = data.lending_health
@@ -154,16 +157,14 @@ def _print_health_lines(market: Any, indent: str) -> None:
     click.secho(f"{indent}Status:        {status}", fg=color, bold=bold)
 
 
-def _print_markets(data: VaultData, api_key: str | None) -> None:
+def _print_markets(data: VaultData, resolve_name: NameResolver) -> None:
     """Fuses, balance fuses, dependency graph and substrates."""
-    chain_id = data.chain_id
     _print_fuse_section(
         "Fuses",
         data.fuses,
         data.fuse_markets,
         data.market_substrates,
-        chain_id,
-        api_key,
+        resolve_name,
     )
     click.echo()
 
@@ -172,18 +173,17 @@ def _print_markets(data: VaultData, api_key: str | None) -> None:
         data.instant_fuses,
         data.fuse_markets,
         data.market_substrates,
-        chain_id,
-        api_key,
+        resolve_name,
     )
     click.echo()
 
-    _print_balance_fuses_table(data, api_key)
+    _print_balance_fuses_table(data, resolve_name)
     click.echo()
 
     _print_dependency_graph(data)
 
     click.echo("Substrates per Market:")
-    _print_market_substrates(data, api_key)
+    _print_market_substrates(data, resolve_name)
     click.echo()
 
 
@@ -235,8 +235,7 @@ def _print_fuse_section(
     fuses: Sequence[FuseAddress],
     fuse_markets: dict[FuseAddress, MarketId] | None,
     market_substrates: dict[MarketId, list[bytes]] | None,
-    chain_id: ChainId,
-    api_key: str | None,
+    resolve_name: NameResolver,
 ) -> None:
     """Render a fuse section (regular or instant-withdrawal) with a unified
     layout.
@@ -262,10 +261,7 @@ def _print_fuse_section(
         return
 
     with ThreadPoolExecutor() as pool:
-        name_futs = {
-            addr: pool.submit(get_contract_name, chain_id, addr, api_key)
-            for addr in counts
-        }
+        name_futs = {addr: pool.submit(resolve_name, addr) for addr in counts}
         rows: list[tuple[str, ...]] = []
         for idx, addr in enumerate(counts, 1):
             market_label = "?"
@@ -285,7 +281,7 @@ def _print_fuse_section(
     _print_table(("#", "Address", "Contract", "Market", "Substrates"), rows)
 
 
-def _print_balance_fuses_table(data: VaultData, api_key: str | None) -> None:
+def _print_balance_fuses_table(data: VaultData, resolve_name: NameResolver) -> None:
     balance_fuses = data.balance_fuses
     decimals = data.asset_decimals
     asset_symbol = data.asset_symbol
@@ -294,9 +290,7 @@ def _print_balance_fuses_table(data: VaultData, api_key: str | None) -> None:
         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_contract = pool.submit(
-                get_contract_name, data.chain_id, balance_fuse.fuse, api_key
-            )
+            f_contract = pool.submit(resolve_name, balance_fuse.fuse)
             futures.append((idx, balance_fuse.market_id, market_id_str, f_contract))
 
         venue_rows: list[tuple[str, ...]] = []
@@ -328,18 +322,18 @@ def _print_balance_fuses_table(data: VaultData, api_key: str | None) -> None:
         _print_table(header, [(str(i), *row) for i, row in enumerate(zero_rows, 1)])
 
 
-def _print_market_substrates(data: VaultData, api_key: str | None) -> set[str]:
+def _print_market_substrates(data: VaultData, resolve_name: NameResolver) -> 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(data, api_key)
+    return _print_substrates(data, resolve_name)
 
 
 def _print_substrates(  # noqa: C901
-    data: VaultData, api_key: str | None
+    data: VaultData, resolve_name: NameResolver
 ) -> set[str]:
     substrates_by_market = data.market_substrates or {}
     balance_fuses = data.balance_fuses
@@ -364,8 +358,7 @@ def _print_substrates(  # noqa: C901
     resolved_symbols = data.token_symbols
     with ThreadPoolExecutor() as pool:
         contract_futs = {
-            addr: pool.submit(get_contract_name, data.chain_id, addr, api_key)
-            for addr in all_addresses
+            addr: pool.submit(resolve_name, addr) for addr in all_addresses
         }
         resolved_contracts = {addr: fut.result() for addr, fut in contract_futs.items()}
 

{ipor_fusion-4.0.0.dev108 → ipor_fusion-4.0.0.dev114}/src/ipor_fusion/core/plasma_vault.py

@@ -191,7 +191,7 @@ class PlasmaVault(ContractWrapper):
         `addFuses` steps must be reverted before the vault is usable."""
         return self._write("removeFuses(address[])", fuses)
 
-    def set_total_supply_cap(self, cap: Amount) -> Call[None]:
+    def set_total_supply_cap(self, cap: Shares) -> Call[None]:
         return self._write("setTotalSupplyCap(uint256)", cap)
 
     def convert_to_public_vault(self) -> Call[None]:
@@ -362,25 +362,26 @@ class PlasmaVault(ContractWrapper):
             "configureInstantWithdrawalFuses((address,bytes32[])[])", normalized
         )
 
-    def transfer(self, to: ChecksumAddress, value: Amount) -> Call[None]:
+    def transfer(self, to: ChecksumAddress, value: Shares) -> Call[None]:
         return self._write("transfer(address,uint256)", to, value)
 
-    def approve(self, account: ChecksumAddress, amount: Amount) -> Call[None]:
+    def approve(self, account: ChecksumAddress, amount: Shares) -> Call[None]:
         return self._write("approve(address,uint256)", account, amount)
 
     def transfer_from(
-        self, _from: ChecksumAddress, to: ChecksumAddress, amount: Amount
+        self, _from: ChecksumAddress, to: ChecksumAddress, amount: Shares
     ) -> Call[None]:
         return self._write("transferFrom(address,address,uint256)", _from, to, amount)
 
-    def balance_of(self, account: ChecksumAddress) -> Call[Amount]:
+    def balance_of(self, account: ChecksumAddress) -> Call[Shares]:
         return self._view(
-            "balanceOf(address)", account, output_types=["uint256"], decoder=Amount
+            "balanceOf(address)", account, output_types=["uint256"], decoder=Shares
         )
 
-    def get_total_supply_cap(self) -> Call[Amount]:
+    def get_total_supply_cap(self) -> Call[Shares]:
+        """The maximum total supply, in shares (``2**256 - 1``: uncapped)."""
         return self._view(
-            "getTotalSupplyCap()", output_types=["uint256"], decoder=Amount
+            "getTotalSupplyCap()", output_types=["uint256"], decoder=Shares
         )
 
     def max_withdraw(self, account: ChecksumAddress) -> Call[Amount]:
@@ -418,8 +419,8 @@ class PlasmaVault(ContractWrapper):
     def total_assets(self) -> Call[Amount]:
         return self._view("totalAssets()", output_types=["uint256"], decoder=Amount)
 
-    def total_supply(self) -> Call[Amount]:
-        return self._view("totalSupply()", output_types=["uint256"], decoder=Amount)
+    def total_supply(self) -> Call[Shares]:
+        return self._view("totalSupply()", output_types=["uint256"], decoder=Shares)
 
     def name(self) -> Call[str]:
         return self._view("name()", output_types=["string"])

{ipor_fusion-4.0.0.dev108 → ipor_fusion-4.0.0.dev114}/src/ipor_fusion/validation.py

@@ -13,6 +13,7 @@ from dataclasses import dataclass, field
 from typing import Protocol, TypeVar
 
 from eth_typing import ChecksumAddress
+from web3.types import Timestamp
 
 from ipor_fusion.core.context import Web3Context
 from ipor_fusion.core.plasma_vault import BalanceFuse
@@ -24,7 +25,15 @@ from ipor_fusion.dependency_graph import (
 from ipor_fusion.market_ids import IporFusionMarkets
 from ipor_fusion.readers.lending_health import VaultLendingHealth
 from ipor_fusion.substrates import decode_substrate, format_market_label
-from ipor_fusion.types import ChainId, FuseAddress, MarketId, PlasmaVaultAddress
+from ipor_fusion.types import (
+    Amount,
+    ChainId,
+    Decimals,
+    FuseAddress,
+    MarketId,
+    PlasmaVaultAddress,
+    Shares,
+)
 from ipor_fusion.types import Check as Check
 from ipor_fusion.types import Severity as Severity
 from ipor_fusion.types import Verdict as Verdict
@@ -57,9 +66,9 @@ class WithdrawQueue(Protocol):
     """The WithdrawManager state the reconciliation needs."""
 
     @property
-    def shares_to_release(self) -> int: ...
+    def shares_to_release(self) -> Shares: ...
     @property
-    def shares_to_release_assets(self) -> int | None: ...
+    def shares_to_release_assets(self) -> Amount | None: ...
 
 
 class UnpriceableToken(Protocol):
@@ -97,19 +106,19 @@ class VaultState(Protocol):
     @property
     def block_number(self) -> int: ...
     @property
-    def block_timestamp(self) -> int: ...
+    def block_timestamp(self) -> Timestamp: ...
     @property
     def asset(self) -> ChecksumAddress: ...
     @property
     def asset_symbol(self) -> str: ...
     @property
-    def asset_decimals(self) -> int: ...
+    def asset_decimals(self) -> Decimals: ...
     @property
     def asset_price_usd(self) -> float | None: ...
     @property
-    def total_assets(self) -> int: ...
+    def total_assets(self) -> Amount: ...
     @property
-    def underlying_balance_on_vault(self) -> int: ...
+    def underlying_balance_on_vault(self) -> Amount: ...
     @property
     def price_oracle_addr(self) -> ChecksumAddress: ...
     @property
@@ -129,7 +138,7 @@ class VaultState(Protocol):
     @property
     def unimplemented_getters(self) -> Sequence[str]: ...
     @property
-    def market_balances(self) -> Mapping[MarketId, int]: ...
+    def market_balances(self) -> Mapping[MarketId, Amount]: ...
     @property
     def erc20(self) -> Erc20Holdings: ...
 

{ipor_fusion-4.0.0.dev108 → ipor_fusion-4.0.0.dev114}/src/ipor_fusion/vault_data.py

@@ -18,7 +18,7 @@ from typing import Any, TypeVar
 from eth_typing import HexAddress
 from eth_utils import function_signature_to_4byte_selector
 from web3 import Web3
-from web3.types import ChecksumAddress
+from web3.types import ChecksumAddress, Timestamp
 
 from ipor_fusion.cache import CacheKey, cache_get, cache_key, cache_put
 from ipor_fusion.chains import ensure_supported_chain
@@ -57,10 +57,13 @@ from ipor_fusion.readers.unpriceable import (
 from ipor_fusion.substrates import decode_substrate
 from ipor_fusion.types import (
     AccessManagerAddress,
+    Amount,
     ChainId,
+    Decimals,
     FuseAddress,
     MarketId,
     PlasmaVaultAddress,
+    Shares,
     parse_hex_address,
 )
 from ipor_fusion.vault_erc20 import Erc20Holdings, _Asset, _read_erc20_holdings
@@ -115,12 +118,12 @@ class VaultData:
     chain_id: ChainId
     block_number: int
     is_latest: bool
-    block_timestamp: int
-    share_decimals: int
-    asset_decimals: int
-    total_assets: int
-    total_supply: int
-    supply_cap: int
+    block_timestamp: Timestamp
+    share_decimals: Decimals
+    asset_decimals: Decimals
+    total_assets: Amount
+    total_supply: Shares
+    supply_cap: Shares
     asset: ChecksumAddress
     asset_symbol: str
     access_manager: AccessManagerAddress
@@ -135,10 +138,10 @@ class VaultData:
     # totalAssets via ERC4626 base accounting; by design NOT tracked as an
     # ERC20_VAULT_BALANCE substrate, so it is read directly in
     # fetch_vault_data rather than derived from substrates.
-    underlying_balance_on_vault: int = 0
+    underlying_balance_on_vault: Amount = Amount(0)
     vault_name: str = ""
     deployment_block: int | None = None
-    deployment_timestamp: int | None = None
+    deployment_timestamp: Timestamp | None = None
     # Short error code from `fetch_deployment_info` when block/timestamp could
     # not be resolved. Surfaced in CLI output and the JSON `deployment` field
     # so users can distinguish "lookup not attempted/failed" from
@@ -186,7 +189,7 @@ class VaultData:
     unimplemented_getters: list[str] = field(default_factory=list)
     # totalAssetsInMarket of every balance-fuse market, once per market, in
     # balance-fuse order.
-    market_balances: dict[MarketId, int] = field(default_factory=dict)
+    market_balances: dict[MarketId, Amount] = field(default_factory=dict)
     # The ERC20_VAULT_BALANCE tokens read directly (empty without that market).
     erc20: Erc20Holdings = field(default_factory=Erc20Holdings)
     # Symbols (lowercase address keys) of the substrate and breakdown tokens,
@@ -215,7 +218,7 @@ def _fuse_market_id_call(fuse: ChecksumAddress) -> Call[int]:
     )
 
 
-_UNCAPPED = 2**256 - 1
+_UNCAPPED = Shares(2**256 - 1)
 
 
 def _missing_required_getter(
@@ -252,9 +255,16 @@ def resolve_token_symbol(ctx: Web3Context, address: HexAddress) -> str:
     return symbol
 
 
-def _cached_decimals(cached: dict[CacheKey, str], key: CacheKey) -> int | None:
-    value = cached.get(key)
-    return int(value) if value is not None and value.isdigit() else None
+def _cached_int(cached: dict[CacheKey, str], key: CacheKey) -> int | None:
+    """A cached non-negative integer; anything else (a corrupt or foreign
+    entry) is a miss."""
+    value = cached.get(key, "")
+    if not (value.isascii() and value.isdigit()):
+        return None
+    try:
+        return int(value)
+    except ValueError:  # beyond the int-string conversion limit
+        return None
 
 
 def resolve_token_decimals(ctx: Web3Context, address: HexAddress) -> int | None:
@@ -262,7 +272,7 @@ def resolve_token_decimals(ctx: Web3Context, address: HexAddress) -> int | None:
     (not cached) when ``address`` has no code at the context's block or does
     not answer."""
     key = cache_key(ctx.chain_id, address, "decimals")
-    if (cached := _cached_decimals(cache_get(ctx.cache, [key]), key)) is not None:
+    if (cached := _cached_int(cache_get(ctx.cache, [key]), key)) is not None:
         return cached
 
     checksum = Web3.to_checksum_address(address)
@@ -278,7 +288,7 @@ def resolve_token_decimals(ctx: Web3Context, address: HexAddress) -> int | None:
     return decimals
 
 
-def _block_timestamp(ctx: Web3Context, block: int) -> int:
+def _block_timestamp(ctx: Web3Context, block: int) -> Timestamp:
     return ctx.web3.eth.get_block(block)["timestamp"]
 
 
@@ -428,7 +438,7 @@ class _MarketReads:
     # Only markets with at least one substrate.
     market_substrates: dict[MarketId, list[bytes]]
     aave_pools: dict[MarketId, ChecksumAddress]
-    market_balances: dict[MarketId, int]
+    market_balances: dict[MarketId, Amount]
     # False when the vault predates getMarketSubstrates (substrates unknown).
     substrates_available: bool = True
 
@@ -696,7 +706,7 @@ def _token_metadata(
     decimals: dict[HexAddress, int | None] = {
         a: value
         for a, k in decimals_keys.items()
-        if (value := _cached_decimals(cached, k)) is not None
+        if (value := _cached_int(cached, k)) is not None
     }
     missing_symbols = sorted((breakdown | substrate_addresses) - symbols.keys())
     missing_decimals = sorted(breakdown - decimals.keys())
@@ -756,7 +766,7 @@ def fetch_deployment_info(
     vault_address: PlasmaVaultAddress,
     *,
     api_key: str | None = None,
-) -> tuple[int | None, int | None, str | None]:
+) -> tuple[int | None, Timestamp | None, str | None]:
     """Return ``(block, timestamp, error)`` for the vault deployment, cached in
     ``ctx.cache``.
 
@@ -771,10 +781,10 @@ def fetch_deployment_info(
     block_key = cache_key(chain_id, vault_address, "deployment_block")
     time_key = cache_key(chain_id, vault_address, "deployment_timestamp")
     cached = cache_get(ctx.cache, [block_key, time_key])
-    if (block := cached.get(block_key, "")).isdigit() and (
-        stamp := cached.get(time_key, "")
-    ).isdigit():
-        return int(block), int(stamp), None
+    block = _cached_int(cached, block_key)
+    stamp = _cached_int(cached, time_key)
+    if block is not None and stamp is not None:
+        return block, Timestamp(stamp), None
 
     tx_hash, error = get_deployment_tx(chain_id, vault_address, api_key)
     if not tx_hash:
@@ -783,7 +793,7 @@ def fetch_deployment_info(
     try:
         tx = ctx.web3.eth.get_transaction(tx_hash)
         block_number: int = tx["blockNumber"]
-        timestamp: int = ctx.web3.eth.get_block(block_number)["timestamp"]
+        timestamp: Timestamp = ctx.web3.eth.get_block(block_number)["timestamp"]
     except Exception:
         return None, None, "rpc-fetch-failed"
     cache_put(ctx.cache, {block_key: str(block_number), time_key: str(timestamp)})

{ipor_fusion-4.0.0.dev108 → ipor_fusion-4.0.0.dev114}/src/ipor_fusion/vault_info.py

@@ -6,7 +6,6 @@ from __future__ import annotations
 from collections.abc import Callable
 from concurrent.futures import Future, ThreadPoolExecutor
 from datetime import UTC, datetime
-from functools import partial
 from typing import Any
 
 from eth_typing import HexAddress
@@ -14,7 +13,6 @@ from eth_typing import HexAddress
 from ipor_fusion.chains import CHAIN_NAMES
 from ipor_fusion.core.fee_manager import HighWaterMarkPerformanceFee, RecipientFee
 from ipor_fusion.core.plasma_vault import BalanceFuse
-from ipor_fusion.explorer import get_contract_name
 from ipor_fusion.field_docs import DOCS
 from ipor_fusion.readers.aave_v3 import AaveV3PositionBreakdown
 from ipor_fusion.readers.hypercore import HyperCorePendingState, HyperCorePerpLeg
@@ -647,7 +645,7 @@ def _supply_cap_json(data: VaultData) -> dict[str, Any]:
         "formatted": (
             "unlimited"
             if data.supply_cap == UINT256_MAX
-            else _format_amount(data.supply_cap, data.asset_decimals)
+            else _format_amount(data.supply_cap, data.share_decimals)
         ),
     }
 
@@ -705,6 +703,10 @@ def _markets_json(
     return markets
 
 
+def _no_name(_address: HexAddress) -> str:
+    return ""
+
+
 def build_vault_info_json(
     data: VaultData,
     *,
@@ -716,14 +718,14 @@ def build_vault_info_json(
     ``data`` comes from `fetch_vault_data` (with ``metadata=True`` for token
     symbols); set its ``deployment_*`` fields first (`fetch_deployment_info`)
     for the ``deployment`` block. ``resolve_name`` names the fuses and
-    substrate contracts (address to contract name, ``""`` when unknown); the
-    default reads `ipor_fusion.explorer.get_contract_name` without an API key,
-    so only names already in the on-disk cache.
+    substrate contracts (address to contract name, ``""`` when unknown), for
+    example `ipor_fusion.explorer.get_contract_name` bound to the chain, an
+    API key and ``ctx.cache``; without it no contract is named.
     """
     chain_id = data.chain_id
     chain_label = CHAIN_NAMES.get(chain_id, str(chain_id))
     if resolve_name is None:
-        resolve_name = partial(get_contract_name, chain_id)
+        resolve_name = _no_name
 
     markets = _markets_json(data, resolve_name)
     validation = validate_vault_state(data)