ipor-fusion 4.1.0.dev26__tar.gz → 4.1.0.dev38__tar.gz

{ipor_fusion-4.1.0.dev26 → ipor_fusion-4.1.0.dev38}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: ipor-fusion
-Version: 4.1.0.dev26
+Version: 4.1.0.dev38
 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.1.0.dev26 → ipor_fusion-4.1.0.dev38}/pyproject.toml

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

{ipor_fusion-4.1.0.dev26 → ipor_fusion-4.1.0.dev38}/src/ipor_fusion/cli/options.py

@@ -2,7 +2,6 @@ from __future__ import annotations
 
 import click
 from eth_typing import ChecksumAddress
-from web3 import Web3
 
 from ipor_fusion.chains import CHAIN_NAME_TO_ID, ensure_supported_chain
 from ipor_fusion.cli.config_store import (
@@ -13,7 +12,12 @@ from ipor_fusion.core.context import Web3Context
 from ipor_fusion.errors import (
     UnsupportedChainError,
 )
-from ipor_fusion.types import ChainId, PlasmaVaultAddress
+from ipor_fusion.types import (
+    ChainId,
+    PlasmaVaultAddress,
+    parse_checksum_address,
+    parse_hex_address,
+)
 
 
 # click < 8.4 does not make ParamType generic, so it cannot be subscripted.
@@ -27,26 +31,18 @@ class AddressType(click.ParamType):  # pyright: ignore[reportMissingTypeArgument
             self.fail(f"expected string, got {type(value).__name__}", param, ctx)
 
         value = value.strip()
-        if not value.startswith("0x"):
-            value = "0x" + value
+        if value[:2] in ("0x", "0X"):
+            value = value[2:]
+        value = "0x" + value
 
-        raw = value[2:]
-        if len(raw) != 40 or not all(c in "0123456789abcdefABCDEF" for c in raw):
+        try:
+            parse_hex_address(value)
+        except ValueError:
             self.fail(f"invalid Ethereum address: {value}", param, ctx)
-
-        if not raw.islower() and not raw.isupper():
-            try:
-                checksum = Web3.to_checksum_address(value)
-            except Exception:
-                self.fail(f"invalid address checksum: {value}", param, ctx)
-            if checksum != value:
-                self.fail(
-                    f"bad checksum — expected {checksum}, got {value}",
-                    param,
-                    ctx,
-                )
-
-        return Web3.to_checksum_address(value)
+        try:
+            return parse_checksum_address(value)
+        except ValueError as exc:
+            self.fail(str(exc), param, ctx)
 
 
 ADDRESS = AddressType()

{ipor_fusion-4.1.0.dev26 → ipor_fusion-4.1.0.dev38}/src/ipor_fusion/core/fusion_factory.py

@@ -38,6 +38,7 @@ from ipor_fusion.types import (
     Period,
     PlasmaVaultAddress,
     parse_access_manager_address,
+    parse_checksum_address,
     parse_plasma_vault_address,
 )
 
@@ -82,8 +83,8 @@ class FusionInstance:
     def from_dict(cls, data: Mapping[str, object]) -> FusionInstance:
         """Rebuild an instance from its JSON form (``dataclasses.asdict``),
         parsing every field: role addresses through their parsers, the rest
-        checksummed, integers and strings type-checked. Raises ``ValueError``
-        on a missing, extra or malformed field."""
+        through `parse_checksum_address`, integers and strings type-checked.
+        Raises ``ValueError`` on a missing, extra or malformed field."""
         names = {f.name for f in fields(cls)}
         missing = names - data.keys()
         extra = data.keys() - names
@@ -128,7 +129,7 @@ def _text(value: object) -> str:
 
 
 def _address(value: object) -> ChecksumAddress:
-    return Web3.to_checksum_address(_text(value))
+    return parse_checksum_address(_text(value))
 
 
 _FUSION_INSTANCE_OUTPUT_TYPES: list[str] = [

{ipor_fusion-4.1.0.dev26 → ipor_fusion-4.1.0.dev38}/src/ipor_fusion/mcp/server.py

@@ -8,6 +8,7 @@ from collections.abc import Callable
 from functools import partial
 from typing import Annotated, Literal
 
+from eth_typing import ChecksumAddress
 from mcp.server.fastmcp import FastMCP
 from pydantic import AfterValidator, BeforeValidator, Field
 from web3 import Web3
@@ -76,8 +77,8 @@ from ipor_fusion.registry import (
 from ipor_fusion.types import (
     ChainId,
     PlasmaVaultAddress,
+    parse_checksum_address,
     parse_morpho_market_id,
-    parse_plasma_vault_address,
 )
 from ipor_fusion.validation import validate_vault
 from ipor_fusion.vault_data import (
@@ -117,14 +118,19 @@ def _resolve_provider(cfg: FusionConfig, chain_id: ChainId) -> str:
     )
 
 
-def _vault_arg(raw: str) -> PlasmaVaultAddress:
-    """A vault address as a tool caller sends it: surrounding whitespace and a
+def _address_arg(raw: str) -> ChecksumAddress:
+    """An address as a tool caller sends it: surrounding whitespace and a
     missing ``0x`` are accepted, as in 3.x; letter case follows
     `parse_checksum_address`, so a wrong EIP-55 checksum is refused."""
     value = raw.strip()
     if value[:2] not in ("0x", "0X"):
         value = "0x" + value
-    return parse_plasma_vault_address(value)
+    return parse_checksum_address(value)
+
+
+def _vault_arg(raw: str) -> PlasmaVaultAddress:
+    """`_address_arg`, labeled as a Plasma Vault's address."""
+    return PlasmaVaultAddress(_address_arg(raw))
 
 
 def _resolve_chain_id(
@@ -341,6 +347,10 @@ def vault_preflight(
         raise ValueError(f"calldata: {exc}") from exc
     if not actions:
         raise ValueError("calldata: the batch has no actions")
+    try:
+        sender_address = _address_arg(sender)
+    except ValueError as exc:
+        raise ValueError(f"sender: {exc}") from exc
     cfg = load_config()
     checksum = _vault_arg(vault_address)
     chain_id = _resolve_chain_id(cfg, checksum, chain_id)
@@ -350,7 +360,7 @@ def vault_preflight(
         ctx,
         checksum,
         actions,
-        sender=Web3.to_checksum_address(sender),
+        sender=sender_address,
         simulate=simulate,
     )
     return ExecutePreflightResponse.model_validate(build_execute_preflight_json(result))
@@ -752,7 +762,7 @@ def market_meta_morpho(
         vault_address: MetaMorpho V1 or Vault V2 address.
         chain_id: EVM chain ID.
     """
-    info = fetch_vault(Web3.to_checksum_address(vault_address), chain_id)
+    info = fetch_vault(_address_arg(vault_address), chain_id)
     payload = build_meta_morpho_json(info, chain_id)
     return MetaMorphoVaultResponse.model_validate(payload)
 

{ipor_fusion-4.1.0.dev26 → ipor_fusion-4.1.0.dev38}/src/ipor_fusion/readers/oracle_mapping.py

@@ -236,15 +236,32 @@ def _resolve_middleware_fallback(
     node.source_type = TYPE_MIDDLEWARE_FALLBACK
     node.status = "resolved"
     if underlying_middleware is not None:
-        # Same asset, different oracle — must not be in `visited` yet; runaway
-        # manager→manager chains are bounded by max_depth instead.
-        dep = _resolve(
-            reader.delegate(underlying_middleware),
-            asset,
-            depth + 1,
-            visited,
-            max_depth,
-        )
+        # Same asset, different oracle: the asset key is not in `visited` yet,
+        # so the hop is keyed by (oracle, asset) — a manager chain that loops
+        # back ends as a cycle instead of running to max_depth.
+        hop = f"{underlying_middleware.lower()}/{asset.lower()}"
+        if hop in visited:
+            return _partial(
+                asset,
+                symbol,
+                decimals,
+                source,
+                TYPE_UNKNOWN,
+                "cycle_detected",
+                [label],
+                price,
+            )
+        visited.add(hop)
+        try:
+            dep = _resolve(
+                reader.delegate(underlying_middleware),
+                asset,
+                depth + 1,
+                visited,
+                max_depth,
+            )
+        finally:
+            visited.discard(hop)
         node.dependencies = [dep]
         # dep re-resolves the same asset, so drop its leading label from the path.
         node.path = [label, "middleware fallback", *dep.path[1:]]

{ipor_fusion-4.1.0.dev26 → ipor_fusion-4.1.0.dev38}/src/ipor_fusion/vault_data.py

@@ -312,7 +312,21 @@ def resolve_token_decimals(ctx: Web3Context, address: HexAddress) -> Decimals |
     return decimals
 
 
-def _block_timestamp(ctx: Web3Context, block: int) -> Timestamp:
+def _latest_head(ctx: Web3Context) -> tuple[int, Timestamp]:
+    """The latest block's number and timestamp from one read.
+
+    Reading the head number first and the block by number second can reach a
+    node behind a load balancer that has not seen that block yet.
+    """
+    head = ctx.web3.eth.get_block("latest")
+    return head["number"], head["timestamp"]
+
+
+def _block_timestamp(
+    ctx: Web3Context, block: int, known: Timestamp | None
+) -> Timestamp:
+    if known is not None:
+        return known
     return ctx.web3.eth.get_block(block)["timestamp"]
 
 
@@ -634,14 +648,18 @@ def fetch_vault_data(
     ensure_supported_chain(ctx.chain_id)
     if block is None:
         block = _pinned_default_block(ctx)
-    resolved_block = ctx.web3.eth.block_number if block is None else block
     is_latest = block is None
+    head_timestamp: Timestamp | None = None
+    if block is None:
+        resolved_block, head_timestamp = _latest_head(ctx)
+    else:
+        resolved_block = block
     ctx = ctx.at_block(resolved_block)
     plasma_vault = PlasmaVault(vault)
     with ThreadPoolExecutor() as pool:
         # Independent pipelines, each a short chain of batched reads; none of
         # them waits on a pool future, so they cannot starve the pool.
-        f_timestamp = pool.submit(_block_timestamp, ctx, resolved_block)
+        f_timestamp = pool.submit(_block_timestamp, ctx, resolved_block, head_timestamp)
         f_vault = pool.submit(_fetch_vault_reads, ctx, plasma_vault)
         f_fees = pool.submit(_fetch_fee_data, ctx, plasma_vault)
         f_withdraw = pool.submit(_fetch_withdraw_manager, ctx, plasma_vault)

ipor_fusion-4.1.0.dev38/tests/_addresses.py

@@ -0,0 +1,17 @@
+"""Address spellings that EIP-55 must reject."""
+
+from web3 import Web3
+
+
+def miscased(address: str) -> str:
+    """``address`` checksummed with one letter's case flipped: the same 20 bytes,
+    a wrong checksum. Only a mixed-case result carries a checksum, so the first
+    flip that leaves the digits mixed case is taken."""
+    checksummed = Web3.to_checksum_address(address)
+    for i, c in enumerate(checksummed[2:], start=2):
+        if c.isalpha():
+            flipped = checksummed[:i] + c.swapcase() + checksummed[i + 1 :]
+            digits = flipped[2:]
+            if digits not in (digits.lower(), digits.upper()):
+                return flipped
+    raise AssertionError(f"no wrong checksum is possible for {address}")

ipor_fusion-4.1.0.dev38/tests/test_addresses_helper.py

@@ -0,0 +1,20 @@
+"""The ``miscased`` test helper returns a spelling EIP-55 rejects, or fails."""
+
+import pytest
+from _addresses import miscased
+
+from ipor_fusion.types import parse_checksum_address
+
+
+def test_skips_a_flip_that_leaves_one_case():
+    # Flipping B gives all lowercase, which carries no checksum.
+    address = "0xBca0000000000000000000000000000000000000"
+    bad = miscased(address)
+    assert bad.lower() == address.lower()
+    with pytest.raises(ValueError, match="invalid address checksum"):
+        parse_checksum_address(bad)
+
+
+def test_fails_when_no_flip_leaves_mixed_case():
+    with pytest.raises(AssertionError, match="no wrong checksum"):
+        miscased("0xCc00000000000000000000000000000000000000")

{ipor_fusion-4.1.0.dev26 → ipor_fusion-4.1.0.dev38}/tests/test_cli_commands.py

@@ -443,7 +443,10 @@ class TestVaultInfo:
         mock_ctx.cache = NullCache()
         mock_ctx.web3.eth.block_number = 12345678
         mock_ctx.default_block = "latest"
-        mock_ctx.web3.eth.get_block.return_value = {"timestamp": 1700000000}
+        mock_ctx.web3.eth.get_block.return_value = {
+            "number": 12345678,
+            "timestamp": 1700000000,
+        }
         mock_ctx.chain_id = 1
         mock_ctx.at_block.return_value = mock_ctx
         mock_ctx_cls.from_url.return_value = mock_ctx
@@ -573,7 +576,10 @@ class TestVaultInfo:
         mock_ctx.cache = NullCache()
         mock_ctx.web3.eth.block_number = 12345678
         mock_ctx.default_block = "latest"
-        mock_ctx.web3.eth.get_block.return_value = {"timestamp": 1700000000}
+        mock_ctx.web3.eth.get_block.return_value = {
+            "number": 12345678,
+            "timestamp": 1700000000,
+        }
         mock_ctx.chain_id = 1
         mock_ctx.at_block.return_value = mock_ctx
         mock_ctx_cls.from_url.return_value = mock_ctx
@@ -654,7 +660,10 @@ class TestVaultInfo:
         mock_ctx.cache = NullCache()
         mock_ctx.web3.eth.block_number = 100
         mock_ctx.default_block = "latest"
-        mock_ctx.web3.eth.get_block.return_value = {"timestamp": 1700000000}
+        mock_ctx.web3.eth.get_block.return_value = {
+            "number": 100,
+            "timestamp": 1700000000,
+        }
         mock_ctx.chain_id = 1
         mock_ctx.at_block.return_value = mock_ctx
         mock_ctx_cls.from_url.return_value = mock_ctx
@@ -723,7 +732,10 @@ class TestVaultInfo:
         mock_ctx.cache = NullCache()
         mock_ctx.web3.eth.block_number = 100
         mock_ctx.default_block = "latest"
-        mock_ctx.web3.eth.get_block.return_value = {"timestamp": 1700000000}
+        mock_ctx.web3.eth.get_block.return_value = {
+            "number": 100,
+            "timestamp": 1700000000,
+        }
         mock_ctx.chain_id = 1
         mock_ctx.at_block.return_value = mock_ctx
         mock_ctx_cls.from_url.return_value = mock_ctx
@@ -804,7 +816,10 @@ class TestVaultInfo:
         mock_ctx.cache = NullCache()
         mock_ctx.web3.eth.block_number = 100
         mock_ctx.default_block = "latest"
-        mock_ctx.web3.eth.get_block.return_value = {"timestamp": 1700000000}
+        mock_ctx.web3.eth.get_block.return_value = {
+            "number": 100,
+            "timestamp": 1700000000,
+        }
         mock_ctx.web3.eth.get_transaction.return_value = {"blockNumber": 18500000}
         mock_ctx.chain_id = 1
         mock_ctx.at_block.return_value = mock_ctx
@@ -875,7 +890,10 @@ class TestVaultInfo:
         mock_ctx.cache = NullCache()
         mock_ctx.web3.eth.block_number = 100
         mock_ctx.default_block = "latest"
-        mock_ctx.web3.eth.get_block.return_value = {"timestamp": 1700000000}
+        mock_ctx.web3.eth.get_block.return_value = {
+            "number": 100,
+            "timestamp": 1700000000,
+        }
         mock_ctx.chain_id = 1
         mock_ctx.at_block.return_value = mock_ctx
         mock_ctx_cls.from_url.return_value = mock_ctx
@@ -986,7 +1004,10 @@ class TestVaultInfoJson:
         mock_ctx.chain_id = 1
         mock_ctx.web3.eth.block_number = 12345678
         mock_ctx.default_block = "latest"
-        mock_ctx.web3.eth.get_block.return_value = {"timestamp": 1700000000}
+        mock_ctx.web3.eth.get_block.return_value = {
+            "number": 12345678,
+            "timestamp": 1700000000,
+        }
         mock_ctx.chain_id = 1
         mock_ctx.at_block.return_value = mock_ctx
         mock_ctx_cls.from_url.return_value = mock_ctx
@@ -1165,7 +1186,10 @@ class TestVaultInfoJson:
         mock_ctx.cache = NullCache()
         mock_ctx.web3.eth.block_number = 100
         mock_ctx.default_block = "latest"
-        mock_ctx.web3.eth.get_block.return_value = {"timestamp": 1700000000}
+        mock_ctx.web3.eth.get_block.return_value = {
+            "number": 100,
+            "timestamp": 1700000000,
+        }
         mock_ctx.web3.eth.get_transaction.return_value = {"blockNumber": 18500000}
         mock_ctx.chain_id = 1
         mock_ctx.at_block.return_value = mock_ctx
@@ -1246,7 +1270,10 @@ class TestVaultInfoJson:
         mock_ctx.cache = NullCache()
         mock_ctx.web3.eth.block_number = 100
         mock_ctx.default_block = "latest"
-        mock_ctx.web3.eth.get_block.return_value = {"timestamp": 1700000000}
+        mock_ctx.web3.eth.get_block.return_value = {
+            "number": 100,
+            "timestamp": 1700000000,
+        }
         mock_ctx.chain_id = 1
         mock_ctx.at_block.return_value = mock_ctx
         mock_ctx_cls.from_url.return_value = mock_ctx

{ipor_fusion-4.1.0.dev26 → ipor_fusion-4.1.0.dev38}/tests/test_cli_helpers.py

@@ -6,6 +6,7 @@ from unittest.mock import MagicMock, patch
 
 import click
 import pytest
+from _addresses import miscased
 from _multicall import decode_aggregate3, multicall_aware
 from _validation import holding, validate
 from click.testing import CliRunner
@@ -131,9 +132,20 @@ class TestAddressType:
         checksum = Web3.to_checksum_address("0x" + "1a2b3c4d5e" * 4)
         assert ADDRESS.convert(checksum, None, None) == checksum
 
+    @pytest.mark.parametrize(
+        "raw",
+        [
+            "0X" + "ab" * 20,
+            "0X" + "AB" * 20,
+            "0X" + VALID_CHECKSUM[2:],
+        ],
+    )
+    def test_valid_with_uppercase_0x_prefix(self, raw: str):
+        assert _convert_via_cli(raw) == VALID_CHECKSUM
+
     def test_bad_checksum_mixed_case(self):
         good = str(Web3.to_checksum_address("0x" + "1a2b3c4d5e" * 4))
-        bad = good[:-1] + good[-1].swapcase()
+        bad = miscased(good)
         runner = CliRunner()
 
         @click.command()
@@ -143,6 +155,8 @@ class TestAddressType:
 
         result = runner.invoke(cmd, [bad])
         assert result.exit_code != 0
+        assert "invalid address checksum" in result.output
+        assert good not in result.output
 
     def test_too_short(self):
         runner = CliRunner()
@@ -1158,17 +1172,6 @@ class TestPrintBalanceFusesTable:
         assert "Zero-Balance Fuses" not in out
 
 
-class TestAddressTypeChecksumException:
-    @patch("ipor_fusion.cli.options.Web3.to_checksum_address")
-    def test_checksum_exception_caught(self, mock_checksum):
-        mock_checksum.side_effect = Exception("unexpected error")
-        mixed = "0xAbCdEf1234567890aBcDeF1234567890AbCdEf12"
-        with pytest.raises(
-            click.exceptions.BadParameter, match="invalid address checksum"
-        ):
-            ADDRESS.convert(mixed, None, None)
-
-
 class TestPrintReconciliation:
     def test_within_threshold(self, capsys):
         data = VaultData(

{ipor_fusion-4.1.0.dev26 → ipor_fusion-4.1.0.dev38}/tests/test_fusion_instance.py

@@ -6,6 +6,7 @@ from __future__ import annotations
 from dataclasses import asdict
 
 import pytest
+from _addresses import miscased
 from web3 import Web3
 
 from ipor_fusion.core.fusion_factory import FusionInstance
@@ -58,6 +59,8 @@ def test_from_dict_checksums_every_address_and_round_trips():
         (lambda d: d.update(extra=1), "extra"),
         (lambda d: d.update(plasma_vault="0x1234"), "address"),
         (lambda d: d.update(plasma_vault=" " + d["plasma_vault"]), "address"),
+        (lambda d: d.update(plasma_vault=miscased(d["plasma_vault"])), "checksum"),
+        (lambda d: d.update(price_manager=miscased(d["price_manager"])), "checksum"),
         (lambda d: d.update(asset_decimals="8"), "integer"),
         (lambda d: d.update(index=True), "integer"),
         (lambda d: d.update(asset_symbol=None), "string"),

{ipor_fusion-4.1.0.dev26 → ipor_fusion-4.1.0.dev38}/tests/test_mcp_preflight.py

@@ -4,6 +4,7 @@ import asyncio
 from unittest.mock import MagicMock, patch
 
 import pytest
+from _addresses import miscased
 from mcp.server.fastmcp.exceptions import ToolError
 from web3 import Web3
 
@@ -26,6 +27,8 @@ from ipor_fusion.types import (
 
 VAULT = PlasmaVaultAddress(Web3.to_checksum_address("0x" + "11" * 20))
 SENDER = Web3.to_checksum_address("0x" + "33" * 20)
+# Hex letters, so it can carry a wrong checksum; SENDER has none.
+SENDER_HEX = "0x" + "ab" * 20
 FUSE = FuseAddress(Web3.to_checksum_address("0x" + "55" * 20))
 ACTION = AaveV3SupplyFuse(FUSE).supply(
     asset=Web3.to_checksum_address("0x" + "44" * 20), amount=Amount(10)
@@ -84,3 +87,9 @@ def test_bad_calldata_is_a_tool_error(preflight):
     with pytest.raises(ToolError, match="no actions"):
         _call(vault_address=VAULT, calldata=empty, sender=SENDER)
     preflight.assert_not_called()
+
+
+def test_wrong_sender_checksum_is_a_tool_error(preflight):
+    with pytest.raises(ToolError, match="sender: invalid address checksum"):
+        _call(vault_address=VAULT, calldata=CALLDATA, sender=miscased(SENDER_HEX))
+    preflight.assert_not_called()

{ipor_fusion-4.1.0.dev26 → ipor_fusion-4.1.0.dev38}/tests/test_mcp_server.py

@@ -5,6 +5,7 @@ import importlib.metadata
 from unittest.mock import ANY, MagicMock, patch
 
 import pytest
+from _addresses import miscased
 from mcp.server.fastmcp.exceptions import ToolError
 from web3 import Web3
 
@@ -770,7 +771,7 @@ _LOAN = "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48"
 _COLLAT = "0xD2af830E8CBdFed6CC11Bab697bB25496ed6FA62"
 _ORACLE = "0x7C65985C35181D51eF7571FA40211B57659B7d80"
 _IRM = "0x870Ac11D48B15db9a138Cf899d20F13F79Ba00BC"
-_VAULT = "0xf9bDdD4A9b3a45F980E11Fdde96E16364DDBec49"
+_VAULT = Web3.to_checksum_address("0xf9bddd4a9b3a45f980e11fdde96e16364ddbec49")
 
 
 def _stub_reader_instance():
@@ -1085,6 +1086,17 @@ class TestMarketMetaMorpho:
         with pytest.raises(MorphoApiError, match="not found"):
             market_meta_morpho(vault_address=_VAULT, chain_id=1)
 
+    @patch("ipor_fusion.mcp.server.fetch_vault", return_value=_v1_info())
+    def test_accepts_padded_bare_lowercase_address(self, fetch):
+        market_meta_morpho(vault_address=f" {_VAULT[2:].lower()} ", chain_id=1)
+        fetch.assert_called_once_with(_VAULT, 1)
+
+    @patch("ipor_fusion.mcp.server.fetch_vault", return_value=_v1_info())
+    def test_rejects_a_wrong_checksum(self, fetch):
+        with pytest.raises(ValueError, match="invalid address checksum"):
+            market_meta_morpho(vault_address=miscased(_VAULT), chain_id=1)
+        fetch.assert_not_called()
+
 
 class TestVaultAddressArgument:
     """Tool callers may pad an address with whitespace or omit its ``0x``; the
@@ -1114,10 +1126,8 @@ class TestVaultAddressArgument:
             _vault_arg(raw)
 
     def test_rejects_a_wrong_checksum(self):
-        checksum = Web3.to_checksum_address(self.VAULT)
-        i = next(i for i, c in enumerate(checksum) if c in "abcdefABCDEF")
-        miscased = checksum[:i] + checksum[i].swapcase() + checksum[i + 1 :]
-        for raw in (miscased, "0X" + miscased[2:], miscased[2:]):
+        bad = miscased(self.VAULT)
+        for raw in (bad, "0X" + bad[2:], bad[2:]):
             with pytest.raises(ValueError, match="invalid address checksum"):
                 _vault_arg(raw)
 

{ipor_fusion-4.1.0.dev26 → ipor_fusion-4.1.0.dev38}/tests/test_oracle_mapping.py

@@ -636,6 +636,26 @@ class TestResolve:
             "chainlink_feed_registry": None,
         }
 
+    def test_manager_delegating_to_itself_ends_as_a_cycle(self):
+        r = FakeReader()
+        weth = addr(1)
+        mw = addr(0x51)
+        zero = Web3.to_checksum_address(om.ZERO_ADDRESS)
+        r.symbols[weth] = "WETH"
+        r.decimals[weth] = 18
+        r.sources[weth] = zero
+        r.prices[weth] = Price(asset=weth, amount=2_000 * 10**18, decimals=18)
+        r.underlying_mw = mw
+        r.delegated = r  # the manager names itself as its underlying middleware
+
+        node = om.resolve_asset(r, weth, max_depth=50)
+
+        # one hop back to the same manager, not 50 down to max_depth
+        (dep,) = node.dependencies
+        assert dep.reason == "cycle_detected"
+        assert not dep.dependencies
+        assert node.status == "partially_resolved"
+
     def test_zero_underlying_middleware_treated_as_absent(self):
         r = FakeReader()
         asset = addr(1)

{ipor_fusion-4.1.0.dev26 → ipor_fusion-4.1.0.dev38}/tests/test_types_and_events.py

@@ -1,6 +1,7 @@
 from dataclasses import dataclass
 
 import pytest
+from _addresses import miscased
 from eth_abi import encode
 from hexbytes import HexBytes
 from web3 import Web3
@@ -161,10 +162,8 @@ class TestChecksumParsers:
         for bad in ("0x1234", " " + self.LOWER):
             with pytest.raises(ValueError):
                 parser(bad)
-        i = next(i for i, c in enumerate(checksum) if c in "abcdefABCDEF")
-        miscased = checksum[:i] + checksum[i].swapcase() + checksum[i + 1 :]
         with pytest.raises(ValueError, match="invalid address checksum"):
-            parser(miscased)
+            parser(miscased(checksum))
         # Two characters swapped: a different address that looks right.
         swapped = checksum[:2] + checksum[3] + checksum[2] + checksum[4:]
         assert swapped[2:4] != checksum[2:4]

{ipor_fusion-4.1.0.dev26 → ipor_fusion-4.1.0.dev38}/tests/test_vault_data_block.py

@@ -5,7 +5,7 @@ import pytest
 from ipor_fusion import Web3Context
 from ipor_fusion.cache import NullCache
 from ipor_fusion.types import ChainId
-from ipor_fusion.vault_data import _pinned_default_block
+from ipor_fusion.vault_data import _latest_head, _pinned_default_block
 
 
 def _ctx() -> tuple[Web3Context, MagicMock]:
@@ -32,3 +32,13 @@ def test_tag_or_hash_resolves_to_its_number_once(tag: str):
     ctx, web3 = _ctx()
     assert _pinned_default_block(ctx.at_block(tag)) == 4242  # type: ignore[arg-type]
     web3.eth.get_block.assert_called_once_with(tag)
+
+
+def test_latest_head_reads_number_and_timestamp_in_one_call():
+    # The head number and then get_block(number) can reach a node behind a
+    # load balancer that has not seen that block yet.
+    web3 = MagicMock()
+    web3.eth.get_block.return_value = {"number": 4242, "timestamp": 1_700_000_000}
+    ctx = Web3Context(web3, ChainId(1), cache=NullCache())
+    assert _latest_head(ctx) == (4242, 1_700_000_000)
+    web3.eth.get_block.assert_called_once_with("latest")