ipor-fusion 4.0.0.dev41__tar.gz → 4.0.0.dev45__tar.gz

{ipor_fusion-4.0.0.dev41 → ipor_fusion-4.0.0.dev45}/PKG-INFO

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

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

{ipor_fusion-4.0.0.dev41 → ipor_fusion-4.0.0.dev45}/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.dev41 → ipor_fusion-4.0.0.dev45}/src/ipor_fusion/cli/vault_cmd.py

@@ -131,7 +131,7 @@ def add(address: ChecksumAddress, label: str | None, chain_id: ChainId | None) -
 
 @vault.command("remove")
 @click.argument("address", type=ADDRESS)
-def remove(address: str) -> None:
+def remove(address: ChecksumAddress) -> None:
     """Remove a saved vault."""
     cfg = load_config()
     before = len(cfg.vaults)

{ipor_fusion-4.0.0.dev41 → ipor_fusion-4.0.0.dev45}/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.dev41 → ipor_fusion-4.0.0.dev45}/src/ipor_fusion/mcp/server.py

@@ -437,6 +437,7 @@ def vault_add(
         label: Human-readable label (fetched from on-chain name() if empty).
         chain_id: Chain ID (auto-detected when only one provider configured).
     """
+    checksum = Web3.to_checksum_address(address)
     cfg = load_config()
 
     if not chain_id:
@@ -451,26 +452,21 @@ def vault_add(
     if not label:
         provider_url = _resolve_provider(cfg, chain_id)
         ctx = Web3Context.from_url(provider_url)
-        checksum = Web3.to_checksum_address(address)
         try:
             label = PlasmaVault(ctx, checksum).name().call()
         except Exception:
             label = checksum
 
     for vault_entry in cfg.vaults:
-        if vault_entry.address.lower() == address.lower():
+        if vault_entry.address.lower() == checksum.lower():
             vault_entry.label = label
             vault_entry.chain_id = chain_id
             save_config(cfg)
-            return ActionResult(message=f"Vault {label} ({address}) updated.")
+            return ActionResult(message=f"Vault {label} ({checksum}) updated.")
 
-    cfg.vaults.append(
-        VaultEntry(
-            address=Web3.to_checksum_address(address), label=label, chain_id=chain_id
-        )
-    )
+    cfg.vaults.append(VaultEntry(address=checksum, label=label, chain_id=chain_id))
     save_config(cfg)
-    return ActionResult(message=f"Vault {label} ({address}) added.")
+    return ActionResult(message=f"Vault {label} ({checksum}) added.")
 
 
 @mcp.tool()
@@ -635,7 +631,7 @@ def market_meta_morpho(
         chain_id: EVM chain ID.
     """
     try:
-        info = fetch_vault(vault_address, chain_id)
+        info = fetch_vault(Web3.to_checksum_address(vault_address), chain_id)
     except MorphoApiError as exc:
         raise ValueError(str(exc)) from exc
     payload = build_meta_morpho_json(info, chain_id)

{ipor_fusion-4.0.0.dev41 → ipor_fusion-4.0.0.dev45}/src/ipor_fusion/morpho_api.py

@@ -91,7 +91,7 @@ class VaultFlowCap:
     fee_wei: int
     max_in: int
     max_out: int
-    admin: str | None  # the address that can configure these flow caps
+    admin: ChecksumAddress | None  # the address that can configure these flow caps
 
 
 @dataclass(slots=True)
@@ -106,7 +106,7 @@ class VaultAllocation:
     total_assets: int
     supply_assets: int  # currently allocated to *this* market
     supply_cap: int  # cap configured by curator for *this* market
-    allocators: list[str]  # addresses with ALLOCATOR_ROLE on the vault
+    allocators: list[ChecksumAddress]  # addresses with ALLOCATOR_ROLE on the vault
     flow_cap: VaultFlowCap | None  # None if PublicAllocator not configured
 
 
@@ -122,8 +122,8 @@ class MorphoApiMarket:
     collateral_token: ChecksumAddress
     collateral_symbol: str
     collateral_decimals: int
-    oracle: str
-    irm: str
+    oracle: ChecksumAddress
+    irm: ChecksumAddress
     supply_assets: int
     borrow_assets: int
     liquidity_assets: int
@@ -190,8 +190,8 @@ def _parse_market(raw: dict) -> MorphoApiMarket:
         collateral_token=_api_address(raw["collateralAsset"]["address"]),
         collateral_symbol=raw["collateralAsset"]["symbol"],
         collateral_decimals=int(raw["collateralAsset"]["decimals"]),
-        oracle=raw["oracle"]["address"],
-        irm=raw["irmAddress"],
+        oracle=_api_address(raw["oracle"]["address"]),
+        irm=_api_address(raw["irmAddress"]),
         supply_assets=int(state.get("supplyAssets") or 0),
         borrow_assets=int(state.get("borrowAssets") or 0),
         liquidity_assets=int(state.get("liquidityAssets") or 0),
@@ -283,8 +283,8 @@ class VaultV2Cap:
     market_id: MorphoBlueMarketId | None
     loan_token: ChecksumAddress | None
     collateral_token: ChecksumAddress | None
-    oracle: str | None
-    irm: str | None
+    oracle: ChecksumAddress | None
+    irm: ChecksumAddress | None
     lltv: int | None
 
     @property
@@ -378,7 +378,7 @@ class VaultV1Info:
 
 
 def fetch_vault(
-    address: str, chain_id: ChainId, *, timeout: float = 10.0
+    address: ChecksumAddress, chain_id: ChainId, *, timeout: float = 10.0
 ) -> VaultV2Info | VaultV1Info:
     """Fetch a Morpho vault by address. Tries V2 first, falls back to V1.
 
@@ -625,7 +625,7 @@ def _parse_vault_v1(raw: dict) -> VaultV1Info:
             fee_wei=int(pac.get("fee") or 0),
             max_in=0,
             max_out=0,
-            admin=pac.get("admin"),
+            admin=_api_optional_address(pac.get("admin")),
         )
         for fc in pac.get("flowCaps") or []:
             if raw_mid := (fc.get("market") or {}).get("marketId"):
@@ -687,10 +687,12 @@ def _parse_vault(raw: dict, market_id: MorphoBlueMarketId) -> VaultAllocation:
                 fee_wei=int(pac.get("fee") or 0),
                 max_in=int(flow_for_market.get("maxIn") or 0),
                 max_out=int(flow_for_market.get("maxOut") or 0),
-                admin=pac.get("admin"),
+                admin=_api_optional_address(pac.get("admin")),
             )
     allocators = [
-        a["address"] for a in (raw.get("allocators") or []) if a.get("address")
+        _api_address(a["address"])
+        for a in (raw.get("allocators") or [])
+        if a.get("address")
     ]
     return VaultAllocation(
         vault_address=_api_address(raw["address"]),

{ipor_fusion-4.0.0.dev41 → ipor_fusion-4.0.0.dev45}/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.dev41 → ipor_fusion-4.0.0.dev45}/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.dev41 → ipor_fusion-4.0.0.dev45}/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.dev41 → ipor_fusion-4.0.0.dev45}/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.dev41 → ipor_fusion-4.0.0.dev45}/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.dev45/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.dev41 → ipor_fusion-4.0.0.dev45}/tests/test_cli_market_morpho_blue.py

@@ -4,6 +4,7 @@
 import json
 from unittest.mock import MagicMock, patch
 
+import pytest
 from click.testing import CliRunner
 from eth_abi import encode
 from web3 import Web3
@@ -18,6 +19,7 @@ from ipor_fusion.morpho_api import (
     MorphoApiMarket,
     VaultAllocation,
     VaultFlowCap,
+    _parse_market,
     fetch_market,
     fetch_vault,
 )
@@ -786,3 +788,31 @@ class TestMetaMorphoCommand:
         assert len(market_caps) == 1
         assert market_caps[0]["loan_token"] == LOAN_TOKEN
         assert market_caps[0]["lltv"] == str(915 * 10**15)
+
+
+class TestMorphoApiAddresses:
+    def _raw(self, oracle: str) -> dict:
+        return {
+            "marketId": "0x" + MARKET_ID,
+            "lltv": "915000000000000000",
+            "loanAsset": {"address": LOAN_TOKEN.lower(), "symbol": "U", "decimals": 6},
+            "collateralAsset": {
+                "address": COLLATERAL_TOKEN,
+                "symbol": "C",
+                "decimals": 18,
+            },
+            "oracle": {"address": oracle},
+            "irmAddress": IRM.lower(),
+            "state": {},
+            "supplyingVaults": [],
+        }
+
+    def test_addresses_are_checksummed(self):
+        market = _parse_market(self._raw(ORACLE.lower()))
+        assert market.loan_token == LOAN_TOKEN
+        assert market.oracle == ORACLE
+        assert market.irm == IRM
+
+    def test_a_malformed_address_is_an_api_error(self):
+        with pytest.raises(MorphoApiError):
+            _parse_market(self._raw("invalid oracle"))

{ipor_fusion-4.0.0.dev41 → ipor_fusion-4.0.0.dev45}/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.dev41 → ipor_fusion-4.0.0.dev45}/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.dev41 → ipor_fusion-4.0.0.dev45}/tests/test_mcp_server.py

@@ -89,12 +89,15 @@ def _config_with_keyed_provider():
     return FusionConfig(providers={"1": "https://rpc.example.com/v2/SECRETKEY"})
 
 
-def _config_with_vault():
+_SAVED_VAULT = "0x43ee0243ea8cf02f7087d8b16c8d2007cc9c7ca2"
+
+
+def _config_with_vault(address: str = _SAVED_VAULT):
     from ipor_fusion.cli.config_store import FusionConfig, VaultEntry
 
     return FusionConfig(
         providers={"1": "https://rpc.example.com"},
-        vaults=[VaultEntry(address="0xABC", label="Test", chain_id=1)],
+        vaults=[VaultEntry(address=address, label="Test", chain_id=1)],
     )
 
 
@@ -264,7 +267,7 @@ class TestConfigShow:
     def test_config_with_vault(self, _):
         result = config_show()
         assert len(result.vaults) == 1
-        assert result.vaults[0].address == "0xABC"
+        assert result.vaults[0].address == Web3.to_checksum_address(_SAVED_VAULT)
 
     @patch(
         "ipor_fusion.mcp.server.load_config",
@@ -319,7 +322,7 @@ class TestVaultList:
     def test_with_vault(self, _):
         result = vault_list()
         assert len(result) == 1
-        assert result[0].address == "0xABC"
+        assert result[0].address == Web3.to_checksum_address(_SAVED_VAULT)
         assert result[0].label == "Test"
         assert result[0].chain_id == 1
 
@@ -348,13 +351,23 @@ class TestVaultAdd:
         with pytest.raises(ValueError):
             vault_add(address="0xDEF", label="New Vault", chain_id=1)
 
+    @patch("ipor_fusion.mcp.server.save_config")
+    @patch(
+        "ipor_fusion.mcp.server.load_config",
+        return_value=_config_with_vault("0xABC"),
+    )
+    def test_a_malformed_saved_entry_is_not_updated(self, mock_load, mock_save):
+        with pytest.raises(ValueError):
+            vault_add(address="0xABC", label="Updated", chain_id=1)
+        mock_save.assert_not_called()
+
     @patch("ipor_fusion.mcp.server.save_config")
     @patch(
         "ipor_fusion.mcp.server.load_config",
         return_value=_config_with_vault(),
     )
     def test_update_existing(self, mock_load, mock_save):
-        result = vault_add(address="0xABC", label="Updated", chain_id=1)
+        result = vault_add(address=_SAVED_VAULT, label="Updated", chain_id=1)
         assert "updated" in result.message.lower()
         saved_cfg = mock_save.call_args[0][0]
         assert len(saved_cfg.vaults) == 1
@@ -368,7 +381,7 @@ class TestVaultRemove:
         return_value=_config_with_vault(),
     )
     def test_remove_existing(self, mock_load, mock_save):
-        result = vault_remove(address="0xABC")
+        result = vault_remove(address=_SAVED_VAULT)
         assert "removed" in result.message.lower()
         saved_cfg = mock_save.call_args[0][0]
         assert len(saved_cfg.vaults) == 0