ipor-fusion 4.0.0.dev43__tar.gz → 4.0.0.dev49__tar.gz

ipor_fusion-4.0.0.dev49/MIGRATION_4.md

@@ -0,0 +1,151 @@
+# Migrating to ipor-fusion 4.0
+
+4.0 gives chain, market and role ids, the crosschain, HyperCore and Morpho ids,
+vault/oracle/token addresses and transaction hashes a nominal type
+(`typing.NewType`) across the public API, and checks the SDK, the examples and a
+typed client with pyright's `reportArgumentType`. Other fields keep their types
+(e.g. `VaultData.access_manager` is still `str`).
+
+The wrappers do not change values: `ChainId(1)` is `1` at runtime. The
+[behavior changes](#behavior-changes) below, however, apply to **every** caller,
+type-checked or not. In particular, `fetch_market` and
+`build_morpho_blue_market_json` no longer add a `0x` prefix themselves: pass
+`parse_morpho_market_id(raw_id)`, never a bare 64-hex string. Type-checked code
+(pyright, mypy, Pylance) also wraps literals and raw values as below. Values the SDK
+returns already carry their type and go back in unwrapped.
+
+All types are importable from `ipor_fusion` (and `ipor_fusion.types`);
+`ChecksumAddress`, `HexAddress` and `HexStr` come from `eth_typing`,
+`BlockIdentifier` from `web3.types`, and `USDC_TOKEN_INDEX` / `hip3_action_asset` from
+`ipor_fusion.fuses.hypercore`. The wrappers label values; they do not validate byte
+widths or address spelling.
+
+## Building the types
+
+| Type | From a literal or raw value |
+|---|---|
+| `ChainId` | `ChainId(1)` |
+| `MarketId` | an `IporFusionMarkets` member, or `MarketId(n)` |
+| `RoleId` | a `Roles` member (accepted as is), or `RoleId(n)`; `Roles.resolve(name)` returns one |
+| `Decimals`, `Period`, `Amount`, ... | `Decimals(8)`, `Period(0)`, `Amount(n)` (unchanged) |
+| `ChecksumAddress` | `Web3.to_checksum_address(value)` |
+| `HexAddress` | any `ChecksumAddress`, or `HexAddress(HexStr("0x..."))` for a lowercase address |
+| `MorphoBlueMarketId` | `parse_morpho_market_id(value)`: 32 bytes or hex in any spelling, always `0x` + 64 lowercase digits |
+| `TxHash` | `TxHash(HexStr("0x..."))` |
+| crosschain ids | `CommandId(b)`, `MessageId(b)`, `AssetId(b)`, `OperationId(b)`, `TransferId(b)`, `ReturnRequestId(b)`, `PositionSetHash(b)` (bytes32); `ProposalId(n)`, `DeploymentRequestId(n)`, `StargateAssetId(n)` (int) |
+| HyperCore ids | `HyperCoreTokenIndex(n)` (or `USDC_TOKEN_INDEX`), `HyperCoreAsset(n)` (or `hip3_action_asset(dex, index)`), `HyperCoreOrderId(n)`, `HyperCoreClientOrderId(n)`, `MarginTableId(n)`, `HyperCoreActionId(n)`, `PayloadHash(b)` |
+| external state | `ProposalHash(b)` |
+| `BlockIdentifier` | a block number, `"latest"` / `"pending"` / ..., or a block hash |
+
+`MessageId` covers both a CCIP `messageId` and a LayerZero `guid`. `AssetId` is the
+crosschain executor's `bytes32` asset id; a Stargate pool's `uint16` asset id is
+`StargateAssetId`. `DeploymentRequestId` is a factory's `uint256` dispatcher request;
+a `bytes32` return (recall) request is `ReturnRequestId`.
+
+## What changed, by area
+
+**Vault reads and validation.** `fetch_vault_data(chain_id=)`, `fetch_deployment_info`,
+`build_vault_info_json`, `ensure_supported_chain`, `fetch_vault_lending_health` take
+`ChainId`; vault and oracle addresses
+(`validate_vault`, `fetch_deployment_info`, `build_vault_info_json`,
+`fetch_unpriceable_priced_tokens`) take `ChecksumAddress`; `resolve_token_symbol`,
+`resolve_token_decimals`, `get_contract_name`, `get_deployment_tx` take `HexAddress`
+(a checksum address fits). The `resolve_name` / `resolve_symbol` callbacks receive a
+`HexAddress` (a callback typed for `str` still fits). Market-keyed data is keyed by
+`MarketId`: `VaultData.market_substrates`, `dependency_graph`, `fuse_markets`,
+`morpho_positions`, `aave_positions`; the `VaultState` protocol, `validate_vault_state`
+(`market_balances`), `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`).
+A custom `VaultState` implementation also annotates `asset` as `ChecksumAddress` and
+its `unpriceable_priced_tokens` items' `market_id` as `MarketId`
+(`UnpriceableToken`). `VaultData.asset`, `VaultValidation.vault` / `asset` are
+`ChecksumAddress`,
+`VaultValidation.chain_id` is `ChainId`; `LendingMarketHealth.market_id` and
+`MiddlewarePricedToken.market_id` are `MarketId`; `Erc20Holding.address` and
+`SubstrateInfo.address` are `HexAddress` (still `""` when a substrate has no address).
+`LegacyPriceOracleMiddleware` takes `base_currency_decimals: Decimals`.
+`get_logs_adaptive(chain_id=)` and `LogSource.get_logs` take `ChainId`;
+`quote_ccip_native_fee(block=)` and `OracleMappingReader.asset_source_events` take a
+`BlockIdentifier`.
+
+**Markets and substrates.** Every `IporFusionMarkets` member is a `MarketId`.
+`decode_substrate`, `market_name`, `format_market_label` take `MarketId`.
+
+**Access.** `AccessManager.has_role`, `grant_role`, `revoke_role`,
+`get_accounts_with_role` take `RoleId | Roles`; `RoleAccount.role_id` is `RoleId`.
+
+**Morpho.** `MorphoBlueMarketId` now always carries `0x`; build it with
+`parse_morpho_market_id` instead of `MorphoBlueMarketId("<64 hex>")`. `fetch_market`,
+`build_morpho_blue_market_json` take it; `MorphoApiMarket.market_id`,
+`VaultV1MarketAllocation.market_id`, `VaultV2Cap.market_id`,
+`MorphoPositionBreakdown.market_id` (as read from substrates) and the keys of
+`VaultV1Info.public_allocator_flow_caps` are canonical. `fetch_market`, `fetch_vault`,
+`morpho_blue_address`, `build_*_json` take `ChainId`; `fetch_vault` takes a
+`ChecksumAddress`. Every address on the `morpho_api` records is `ChecksumAddress`;
+optional ones (`curator`, `guardian`, `fee_recipient`, `performance_fee_recipient`,
+`management_fee_recipient`, `inner_vault`, `VaultFlowCap.admin`, the `VaultV2Cap`
+market params) are `ChecksumAddress | None`.
+
+**Crosschain.** The executor, dispatcher and factory wrappers, the lanes and
+`StargateCrosschainCommandFuse.enter(request_id=)` take the crosschain ids above, and
+their getters return them (`active_command`, `active_proposal_id`, `propose_balance`
+on CCIP, `active_return` → `OperationId`, `asset_id`, `tracked_position_set_hash`,
+`pending_request_by_chain`, `CrosschainLane.proposal_id_from_logs` /
+`proposal_id_from_receipt`). Records carry them too: `Command`, `ActiveCommand`,
+`ExecutorInitParams`, `BalanceObservation`, `LaneObservation`, `Observation`,
+`CcipObservation`, `OutboundMessage`, `CcipMessageSent`, `Any2EVMMessage`,
+`VerifierResult`, `Packet.guid`, `TaxiMessage`, `StargateChain`; and the helpers
+`fetch_verifier_result(message_id=)`, `lz_receive_calldata(guid=)` and
+`lz_compose_calldata(guid=)` take a `MessageId`. Decoded event values
+(`ccip_events` → `CcipEvent.values`) stay a generic mapping: convert a value
+before passing it on.
+
+**HyperCore (preview).** The fuses, `HyperCoreSubstrates`, `HyperCoreReader`,
+`read_hypercore_transfer_snapshot` and the helpers `system_address`, `read_index_of`,
+`perp_dex_of`, `is_native_perp_asset`, `is_hip3_asset` take the HyperCore ids;
+`HyperCorePerpAssetInfo`, `HyperCorePerpMarket`, `HyperCoreSpotLeg`,
+`HyperCorePendingState` and `HyperCoreTransferSnapshot` carry them.
+
+**External state.** `ExternalStateExecutor.proposal_hash` returns and `confirm_balance`
+takes a `ProposalHash`; `BalanceProposal.proposal_hash` and `NavMark.proposal_hash`
+are `ProposalHash`; `ExternalStateEvent.transaction_hash` is a `TxHash`.
+
+**Errors and explorer.** `TransactionError(tx_hash=)` takes a `TxHash`,
+`LogScanError(address=)` a `ChecksumAddress`; `get_deployment_tx` returns a `TxHash`.
+
+**MCP response models** (Python constructors only; the JSON schemas are unchanged
+except below): `chain_id` fields are `ChainId`, `role_id` `RoleId`, `market_id`
+`MarketId`. Calling an MCP tool function directly from Python takes `ChainId`.
+
+**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
+`ipor_fusion.cli.vault_cmd` was split into `options`, `vault_info_view`,
+`vault_markets_view` and `oracle_mapping_view` (private names, not API).
+
+## Behavior changes
+
+- The MCP `vault_info` document reports the vault address checksummed (the CLI
+  already did).
+- `fusion market meta-morpho --json` and the MCP `market_meta_morpho` tool report
+  `null` instead of `""` for an absent curator, guardian or fee recipient; the MCP
+  schema's `curator` is nullable.
+- The Morpho API client checksums every address it returns (market, vault,
+  allocation, adapter and cap records, and the `fusion market` / MCP market documents
+  built from them), so string comparisons against the API's own spelling change.
+- It raises `MorphoApiError` for a market id or address it parses (market and V1
+  allocation ids, V1 flow-cap ids, vault/asset/owner/token/oracle/IRM/allocator
+  addresses) when the value is invalid, or absent where the field is optional in the
+  answer. A key the parser requires can instead raise `KeyError`, e.g. a `loanAsset`
+  without `address`. When matching a market's own allocation and flow cap, an id that
+  does not parse matches nothing, and a V1 flow cap without an id is skipped, as
+  before. `--market` rejects a malformed id.
+- `LendingMarketHealth.substrate_id` for a Morpho market is `0x`-prefixed (the JSON
+  documents already were).
+- `TransactionError.tx_hash` is `0x`-prefixed.
+- Saved config entries are checksummed when loaded; the MCP `vault_add` tool rejects
+  a value that is not an address.
+- The on-disk caches (`~/.cache/ipor-fusion/`) key addresses lowercased; older entries
+  are rekeyed on load, so a contract name cached for one spelling now also resolves
+  for the other.

{ipor_fusion-4.0.0.dev43 → ipor_fusion-4.0.0.dev49}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: ipor-fusion
-Version: 4.0.0.dev43
+Version: 4.0.0.dev49
 Summary: The IPOR Fusion SDK for Python
 Project-URL: homepage, https://ipor.io
 Project-URL: repository, https://github.com/IPOR-Labs/ipor-fusion.py
@@ -115,6 +115,10 @@ alt="Release">
   </tr>
 </table>
 
+> **Upgrading from 3.x?** 4.0 types the public API's ids and addresses and changes
+> a few behaviors (Morpho market ids, nullable optional addresses); see
+> [MIGRATION_4.md](MIGRATION_4.md).
+
 ## Quickstart
 
 ### Install

{ipor_fusion-4.0.0.dev43 → ipor_fusion-4.0.0.dev49}/README.md

@@ -69,6 +69,10 @@ alt="Release">
   </tr>
 </table>
 
+> **Upgrading from 3.x?** 4.0 types the public API's ids and addresses and changes
+> a few behaviors (Morpho market ids, nullable optional addresses); see
+> [MIGRATION_4.md](MIGRATION_4.md).
+
 ## Quickstart
 
 ### Install

{ipor_fusion-4.0.0.dev43 → ipor_fusion-4.0.0.dev49}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "ipor-fusion"
-version = "4.0.0.dev43"
+version = "4.0.0.dev49"
 description = "The IPOR Fusion SDK for Python"
 authors = [
     { name = "Adam Mydlarz", email = "amydlarz@gmail.com" },
@@ -165,3 +165,4 @@ packages = ["src/ipor_fusion"]
 # semantic-release before `build_command`, so each wheel carries its own entry.
 [tool.hatch.build.targets.wheel.force-include]
 "CHANGELOG.md" = "ipor_fusion/CHANGELOG.md"
+"MIGRATION_4.md" = "ipor_fusion/MIGRATION_4.md"

{ipor_fusion-4.0.0.dev43 → ipor_fusion-4.0.0.dev49}/src/ipor_fusion/cache.py

@@ -9,6 +9,8 @@ import os
 import threading
 from pathlib import Path
 
+from eth_typing import HexAddress
+
 
 def _xdg_cache_home() -> Path:
     return Path(os.environ.get("XDG_CACHE_HOME", Path.home() / ".cache"))
@@ -21,11 +23,35 @@ DEPLOYMENT_CACHE_FILE = CACHE_DIR / "deployment_cache.json"
 _cache_lock = threading.Lock()
 
 
+def cache_key(scope: object, address: HexAddress) -> str:
+    """``<scope>:<address>`` with the address lowercased: one entry per address
+    whatever spelling the caller holds. ``scope`` is a chain id or a field name
+    (``symbol``, ``decimals``)."""
+    return f"{scope}:{address.lower()}"
+
+
+def _canonical(entries: dict) -> dict:
+    """Entries keyed by `cache_key` spelling. Caches written before 4.0 keyed
+    the address as the caller spelled it; an entry already canonical wins over
+    a differently spelled duplicate."""
+    out: dict = {}
+    for key, value in entries.items():
+        scope, sep, address = key.rpartition(":")
+        canonical = cache_key(scope, address) if sep else key
+        if canonical == key or canonical not in out:
+            out[canonical] = value
+    return out
+
+
+def _read(path: Path) -> dict:
+    if not path.exists():
+        return {}
+    return _canonical(json.loads(path.read_text(encoding="utf-8")))
+
+
 def load_contract_cache() -> dict[str, str]:
     with _cache_lock:
-        if not CACHE_FILE.exists():
-            return {}
-        return json.loads(CACHE_FILE.read_text(encoding="utf-8"))  # type: ignore[no-any-return]
+        return _read(CACHE_FILE)
 
 
 def save_contract_cache(cache: dict[str, str]) -> None:
@@ -37,9 +63,7 @@ def save_contract_cache(cache: dict[str, str]) -> None:
 def update_contract_cache(key: str, value: str) -> None:
     with _cache_lock:
         CACHE_DIR.mkdir(parents=True, exist_ok=True)
-        existing: dict[str, str] = {}
-        if CACHE_FILE.exists():
-            existing = json.loads(CACHE_FILE.read_text(encoding="utf-8"))
+        existing: dict[str, str] = _read(CACHE_FILE)
         existing[key] = value
         CACHE_FILE.write_text(json.dumps(existing, indent=2), encoding="utf-8")
 
@@ -49,17 +73,13 @@ _deployment_cache_lock = threading.Lock()
 
 def load_deployment_cache() -> dict[str, dict[str, int]]:
     with _deployment_cache_lock:
-        if not DEPLOYMENT_CACHE_FILE.exists():
-            return {}
-        return json.loads(DEPLOYMENT_CACHE_FILE.read_text(encoding="utf-8"))  # type: ignore[no-any-return]
+        return _read(DEPLOYMENT_CACHE_FILE)
 
 
 def update_deployment_cache(key: str, block: int, timestamp: int) -> None:
     with _deployment_cache_lock:
         CACHE_DIR.mkdir(parents=True, exist_ok=True)
-        existing: dict[str, dict[str, int]] = {}
-        if DEPLOYMENT_CACHE_FILE.exists():
-            existing = json.loads(DEPLOYMENT_CACHE_FILE.read_text(encoding="utf-8"))
+        existing: dict[str, dict[str, int]] = _read(DEPLOYMENT_CACHE_FILE)
         existing[key] = {"block": block, "timestamp": timestamp}
         DEPLOYMENT_CACHE_FILE.write_text(
             json.dumps(existing, indent=2), encoding="utf-8"

{ipor_fusion-4.0.0.dev43 → ipor_fusion-4.0.0.dev49}/src/ipor_fusion/explorer.py

@@ -12,7 +12,7 @@ from urllib.request import urlopen
 
 from eth_typing import HexAddress, HexStr
 
-from ipor_fusion.cache import load_contract_cache, update_contract_cache
+from ipor_fusion.cache import cache_key, load_contract_cache, update_contract_cache
 from ipor_fusion.types import ChainId, TxHash
 
 ETHERSCAN_V2_URL = "https://api.etherscan.io/v2/api"
@@ -44,13 +44,13 @@ def get_contract_name(
     chain_id: ChainId, address: HexAddress, api_key: str | None = None
 ) -> str:
     cache = load_contract_cache()
-    cache_key = f"{chain_id}:{address}"
+    key = cache_key(chain_id, address)
 
-    if cached := cache.get(cache_key):
+    if cached := cache.get(key):
         return cached
 
     if name := _fetch_contract_name(chain_id, address, api_key):
-        update_contract_cache(cache_key, name)
+        update_contract_cache(key, name)
         return name
     return ""
 

{ipor_fusion-4.0.0.dev43 → ipor_fusion-4.0.0.dev49}/src/ipor_fusion/vault_data.py

@@ -25,6 +25,7 @@ from web3.exceptions import ContractLogicError, TimeExhausted, Web3RPCError
 from web3.types import ChecksumAddress, HexStr
 
 from ipor_fusion.cache import (
+    cache_key,
     load_contract_cache,
     load_deployment_cache,
     update_contract_cache,
@@ -325,14 +326,14 @@ def resolve_token_symbol(ctx: Web3Context, address: HexAddress) -> str:
     """ERC-20 symbol, cached; ``"no contract"`` when nothing is deployed at
     ``address`` and ``""`` when the symbol cannot be read."""
     cache = load_contract_cache()
-    cache_key = f"symbol:{address}"
-    if cached := cache.get(cache_key):
+    key = cache_key("symbol", address)
+    if cached := cache.get(key):
         return cached
 
     checksum = Web3.to_checksum_address(address)
     code = ctx.web3.eth.get_code(checksum)
     if not code or code == b"":
-        update_contract_cache(cache_key, _NO_CONTRACT)
+        update_contract_cache(key, _NO_CONTRACT)
         return _NO_CONTRACT
 
     try:
@@ -340,15 +341,15 @@ def resolve_token_symbol(ctx: Web3Context, address: HexAddress) -> str:
     except Exception:
         symbol = ""
     if symbol:
-        update_contract_cache(cache_key, symbol)
+        update_contract_cache(key, symbol)
     return symbol
 
 
 def resolve_token_decimals(ctx: Web3Context, address: HexAddress) -> int | None:
     """Resolve ERC-20 decimals, cached. Returns None if address is not a contract."""
     cache = load_contract_cache()
-    cache_key = f"decimals:{address}"
-    if cached := cache.get(cache_key):
+    key = cache_key("decimals", address)
+    if cached := cache.get(key):
         return int(cached)
 
     checksum = Web3.to_checksum_address(address)
@@ -360,7 +361,7 @@ def resolve_token_decimals(ctx: Web3Context, address: HexAddress) -> int | None:
         decimals = ERC20(ctx, checksum).decimals().call()
     except Exception:
         return None
-    update_contract_cache(cache_key, str(decimals))
+    update_contract_cache(key, str(decimals))
     return decimals
 
 
@@ -1053,9 +1054,9 @@ def fetch_deployment_info(
     Base/Optimism on the free Etherscan tier). ``None`` means either success or
     a benign empty response.
     """
-    cache_key = f"{chain_id}:{vault_address}"
+    key = cache_key(chain_id, vault_address)
     cache = load_deployment_cache()
-    if entry := cache.get(cache_key):
+    if entry := cache.get(key):
         return entry["block"], entry["timestamp"], None
 
     tx_hash, error = get_deployment_tx(chain_id, vault_address, api_key)
@@ -1067,7 +1068,7 @@ def fetch_deployment_info(
         block_number: int = tx["blockNumber"]
         block_info = ctx.web3.eth.get_block(block_number)
         timestamp: int = block_info["timestamp"]
-        update_deployment_cache(cache_key, block_number, timestamp)
+        update_deployment_cache(key, block_number, timestamp)
         return block_number, timestamp, None
     except Exception:
         return None, None, "rpc-fetch-failed"

{ipor_fusion-4.0.0.dev43 → ipor_fusion-4.0.0.dev49}/tests/fixtures/vault_info_golden/clean.json

@@ -69,7 +69,8 @@
     "AAVE_V3 (1)": [
       {
         "address": "0x00000000000000000000000000000000000000a1",
-        "symbol": "USDC"
+        "symbol": "USDC",
+        "contract": "FiatTokenProxy"
       }
     ]
   },

{ipor_fusion-4.0.0.dev43 → ipor_fusion-4.0.0.dev49}/tests/fixtures/vault_info_golden/clean.txt

@@ -36,7 +36,7 @@ Balance Fuses (1):
 
 Substrates per Market:
   AAVE_V3 (1):
-    0x00000000000000000000000000000000000000a1 (symbol=USDC)
+    0x00000000000000000000000000000000000000a1 (symbol=USDC, contract=FiatTokenProxy)
 
 ERC20 Balances (vault holdings):
   (no ERC20_VAULT_BALANCE market)

{ipor_fusion-4.0.0.dev43 → ipor_fusion-4.0.0.dev49}/tests/fixtures/vault_info_golden/rich.json

@@ -143,7 +143,8 @@
     "AAVE_V3 (1)": [
       {
         "address": "0x00000000000000000000000000000000000000a1",
-        "symbol": "USDC"
+        "symbol": "USDC",
+        "contract": "FiatTokenProxy"
       }
     ],
     "MORPHO (14)": [
@@ -155,7 +156,8 @@
     "ERC20_VAULT_BALANCE (7)": [
       {
         "address": "0x00000000000000000000000000000000000000a1",
-        "symbol": "USDC"
+        "symbol": "USDC",
+        "contract": "FiatTokenProxy"
       },
       {
         "address": "0x00000000000000000000000000000000000000b1",

{ipor_fusion-4.0.0.dev43 → ipor_fusion-4.0.0.dev49}/tests/fixtures/vault_info_golden/rich.txt

@@ -53,17 +53,17 @@ Dependency Balance Graph:
 
 Substrates per Market:
   AAVE_V3 (1):
-    0x00000000000000000000000000000000000000a1 (symbol=USDC)
+    0x00000000000000000000000000000000000000a1 (symbol=USDC, contract=FiatTokenProxy)
   MORPHO (14):
     0xabababababababababababababababababababababababababababababababab (morpho_market_id)
   ERC20_VAULT_BALANCE (7):
-    0x00000000000000000000000000000000000000a1 (symbol=USDC)
+    0x00000000000000000000000000000000000000a1 (symbol=USDC, contract=FiatTokenProxy)
     0x00000000000000000000000000000000000000b1 (symbol=STALE)
     0x00000000000000000000000000000000000000b2 (symbol=NOPRICE)
     0x00000000000000000000000000000000000000b3 (symbol=EMPTY)
     0x00000000000000000000000000000000000000b4 (symbol=BROKEN)
   AAVE_V3 (1):
-    0x00000000000000000000000000000000000000a1 (symbol=USDC)
+    0x00000000000000000000000000000000000000a1 (symbol=USDC, contract=FiatTokenProxy)
 
 ERC20 Balances (vault holdings):
   Token                                       Symbol   Balance        Price  Note                                             

ipor_fusion-4.0.0.dev49/tests/test_cache.py

@@ -0,0 +1,99 @@
+import json
+
+import pytest
+
+from ipor_fusion import cache
+from ipor_fusion.cache import load_contract_cache, save_contract_cache
+
+
+@pytest.fixture(autouse=True)
+def _patch_paths(tmp_path, monkeypatch):
+    cache_dir = tmp_path / ".cache"
+    monkeypatch.setattr(cache, "CACHE_DIR", cache_dir)
+    monkeypatch.setattr(cache, "CACHE_FILE", cache_dir / "contract_cache.json")
+
+
+class TestLoadContractCache:
+    def test_returns_empty_dict_when_no_file(self):
+        assert load_contract_cache() == {}
+
+    def test_loads_existing_cache(self, tmp_path):
+        cache_dir = tmp_path / ".cache"
+        cache_dir.mkdir()
+        cache = {"0xABC": "ERC20", "0xDEF": "PlasmaVault"}
+        (cache_dir / "contract_cache.json").write_text(
+            json.dumps(cache), encoding="utf-8"
+        )
+
+        assert load_contract_cache() == cache
+
+
+class TestSaveContractCache:
+    def test_creates_directory_and_writes_json(self, tmp_path):
+        cache = {"0xABC": "ERC20"}
+        save_contract_cache(cache)
+
+        cache_file = tmp_path / ".cache" / "contract_cache.json"
+        assert cache_file.exists()
+        assert json.loads(cache_file.read_text(encoding="utf-8")) == cache
+
+    def test_roundtrip(self):
+        original = {"0x111": "TokenA", "0x222": "TokenB"}
+        save_contract_cache(original)
+        loaded = load_contract_cache()
+        assert loaded == original
+
+
+class TestCanonicalKeys:
+    CHECKSUM = "0xAbCdEf0123456789aBcDeF0123456789AbCdEf01"
+
+    def _write(self, tmp_path, name, entries):
+        cache_dir = tmp_path / ".cache"
+        cache_dir.mkdir(exist_ok=True)
+        (cache_dir / name).write_text(json.dumps(entries), encoding="utf-8")
+
+    def test_a_key_lowercases_only_the_address(self):
+        assert cache.cache_key("symbol", self.CHECKSUM) == (
+            "symbol:" + self.CHECKSUM.lower()
+        )
+        assert cache.cache_key(1, self.CHECKSUM) == "1:" + self.CHECKSUM.lower()
+
+    def test_a_legacy_key_spelled_by_the_caller_still_hits(self, tmp_path):
+        self._write(tmp_path, "contract_cache.json", {f"1:{self.CHECKSUM}": "Vault"})
+        assert load_contract_cache()[cache.cache_key(1, self.CHECKSUM)] == "Vault"
+
+    def test_an_already_canonical_entry_wins_over_a_duplicate(self, tmp_path):
+        self._write(
+            tmp_path,
+            "contract_cache.json",
+            {
+                f"symbol:{self.CHECKSUM.lower()}": "NEW",
+                f"symbol:{self.CHECKSUM}": "OLD",
+            },
+        )
+        assert load_contract_cache() == {f"symbol:{self.CHECKSUM.lower()}": "NEW"}
+
+    def test_an_update_rewrites_legacy_keys(self, tmp_path):
+        self._write(tmp_path, "contract_cache.json", {f"1:{self.CHECKSUM}": "Vault"})
+        cache.update_contract_cache(cache.cache_key("decimals", self.CHECKSUM), "6")
+        on_disk = json.loads(
+            (tmp_path / ".cache" / "contract_cache.json").read_text(encoding="utf-8")
+        )
+        assert on_disk == {
+            f"1:{self.CHECKSUM.lower()}": "Vault",
+            f"decimals:{self.CHECKSUM.lower()}": "6",
+        }
+
+    def test_deployment_entries_are_canonical(self, tmp_path, monkeypatch):
+        monkeypatch.setattr(
+            cache,
+            "DEPLOYMENT_CACHE_FILE",
+            tmp_path / ".cache" / "deployment_cache.json",
+        )
+        self._write(
+            tmp_path,
+            "deployment_cache.json",
+            {f"1:{self.CHECKSUM}": {"block": 5, "timestamp": 6}},
+        )
+        loaded = cache.load_deployment_cache()
+        assert loaded[cache.cache_key(1, self.CHECKSUM)] == {"block": 5, "timestamp": 6}

{ipor_fusion-4.0.0.dev43 → ipor_fusion-4.0.0.dev49}/tests/test_cli_vault_info_golden.py

@@ -362,6 +362,10 @@ def test_vault_info_output_matches_fixture(scenario: str, json_output: bool) ->
         json.loads(rendered)
 
 
+# The CLI's cached lookup matches an address in any spelling; so does this one.
+_NAMES_BY_ADDRESS = {address.lower(): name for address, name in NAMES.items()}
+
+
 @pytest.mark.usefixtures("isolated_cache")
 @pytest.mark.parametrize("scenario", sorted(SCENARIOS))
 def test_public_builder_renders_the_cli_json(scenario: str) -> None:
@@ -377,7 +381,7 @@ def test_public_builder_renders_the_cli_json(scenario: str) -> None:
         VAULT,
         1,
         "ethereum",
-        resolve_name=lambda address: NAMES.get(address, ""),
+        resolve_name=lambda address: _NAMES_BY_ADDRESS.get(address.lower(), ""),
     )
     expected = (FIXTURES / f"{scenario}.json").read_text(encoding="utf-8")
     assert json.dumps(result, indent=2) + "\n" == expected

{ipor_fusion-4.0.0.dev43 → ipor_fusion-4.0.0.dev49}/tests/test_explorer.py

@@ -59,7 +59,7 @@ class TestGetContractName:
         cache_file = tmp_path / ".cache" / "contract_cache.json"
         assert cache_file.exists()
         cached = json.loads(cache_file.read_text(encoding="utf-8"))
-        assert cached["1:0xDEF"] == "PlasmaVault"
+        assert cached["1:0xdef"] == "PlasmaVault"
 
     def test_returns_empty_for_unsupported_chain(self):
         result = get_contract_name(99999, "0xABC", api_key="key123")

ipor_fusion-4.0.0.dev43/tests/test_cache.py

@@ -1,44 +0,0 @@
-import json
-
-import pytest
-
-from ipor_fusion import cache
-from ipor_fusion.cache import load_contract_cache, save_contract_cache
-
-
-@pytest.fixture(autouse=True)
-def _patch_paths(tmp_path, monkeypatch):
-    cache_dir = tmp_path / ".cache"
-    monkeypatch.setattr(cache, "CACHE_DIR", cache_dir)
-    monkeypatch.setattr(cache, "CACHE_FILE", cache_dir / "contract_cache.json")
-
-
-class TestLoadContractCache:
-    def test_returns_empty_dict_when_no_file(self):
-        assert load_contract_cache() == {}
-
-    def test_loads_existing_cache(self, tmp_path):
-        cache_dir = tmp_path / ".cache"
-        cache_dir.mkdir()
-        cache = {"0xABC": "ERC20", "0xDEF": "PlasmaVault"}
-        (cache_dir / "contract_cache.json").write_text(
-            json.dumps(cache), encoding="utf-8"
-        )
-
-        assert load_contract_cache() == cache
-
-
-class TestSaveContractCache:
-    def test_creates_directory_and_writes_json(self, tmp_path):
-        cache = {"0xABC": "ERC20"}
-        save_contract_cache(cache)
-
-        cache_file = tmp_path / ".cache" / "contract_cache.json"
-        assert cache_file.exists()
-        assert json.loads(cache_file.read_text(encoding="utf-8")) == cache
-
-    def test_roundtrip(self):
-        original = {"0x111": "TokenA", "0x222": "TokenB"}
-        save_contract_cache(original)
-        loaded = load_contract_cache()
-        assert loaded == original