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

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

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

@@ -1,6 +1,6 @@
 [project]
 name = "ipor-fusion"
-version = "4.1.0.dev26"
+version = "4.1.0.dev35"
 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.dev35}/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.dev35}/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.dev35}/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.dev35/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.dev35/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.dev35}/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.dev35}/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.dev35}/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.dev35}/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.dev35}/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]