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

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

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

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