ipor-fusion 4.0.0.dev35__tar.gz → 4.0.0.dev39__tar.gz

{ipor_fusion-4.0.0.dev35 → ipor_fusion-4.0.0.dev39}/PKG-INFO

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

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

{ipor_fusion-4.0.0.dev35 → ipor_fusion-4.0.0.dev39}/src/ipor_fusion/cli/config_store.py

@@ -6,7 +6,9 @@ from pathlib import Path
 from urllib.parse import urlsplit
 
 import click
-from pydantic import BaseModel, Field, ValidationError, model_validator
+from eth_typing import ChecksumAddress
+from pydantic import BaseModel, Field, ValidationError, field_validator, model_validator
+from web3 import Web3
 
 from ipor_fusion.types import ChainId
 
@@ -22,10 +24,19 @@ CONFIG_VERSION = 1
 
 
 class VaultEntry(BaseModel):
-    address: str
+    address: ChecksumAddress
     label: str
     chain_id: ChainId
 
+    @field_validator("address", mode="before")
+    @classmethod
+    def _checksum(cls, value: object) -> object:
+        # Configs written before 4.0 may hold any spelling; a value that is not
+        # an address is left for the commands to report, not for every load to fail.
+        if isinstance(value, str) and Web3.is_address(value):
+            return Web3.to_checksum_address(value)
+        return value
+
 
 class FusionConfig(BaseModel):
     providers: dict[str, str] = Field(default_factory=dict)

{ipor_fusion-4.0.0.dev35 → ipor_fusion-4.0.0.dev39}/src/ipor_fusion/cli/market_cmd.py

@@ -389,12 +389,12 @@ def _print_vault_v2(
     click.echo("")
     click.echo("Roles:")
     click.echo(f"  Owner:            {vault.owner}")
-    click.echo(f"  Curator:          {vault.curator}")
+    click.echo(f"  Curator:          {vault.curator or ''}")
     click.echo(
-        f"  Performance fee:  {vault.performance_fee * 100:.2f}% → {vault.performance_fee_recipient}"
+        f"  Performance fee:  {vault.performance_fee * 100:.2f}% → {vault.performance_fee_recipient or ''}"
     )
     click.echo(
-        f"  Management fee:   {vault.management_fee * 100:.2f}% → {vault.management_fee_recipient}"
+        f"  Management fee:   {vault.management_fee * 100:.2f}% → {vault.management_fee_recipient or ''}"
     )
     click.echo(f"  Allocators ({len(vault.allocators)}):")
     for addr in vault.allocators or ["(none)"]:
@@ -515,13 +515,13 @@ def _print_vault_v1(
         f"({_format_amount(vault.total_assets, vault.asset_decimals)} total)"
     )
     click.echo(
-        f"  Performance fee:  {vault.fee_wad / WAD * 100:.2f}% → {vault.fee_recipient}"
+        f"  Performance fee:  {vault.fee_wad / WAD * 100:.2f}% → {vault.fee_recipient or ''}"
     )
     click.echo("")
     click.echo("Roles:")
     click.echo(f"  Owner:            {vault.owner}")
-    click.echo(f"  Curator:          {vault.curator}")
-    click.echo(f"  Guardian:         {vault.guardian}")
+    click.echo(f"  Curator:          {vault.curator or ''}")
+    click.echo(f"  Guardian:         {vault.guardian or ''}")
     click.echo(f"  Allocators ({len(vault.allocators)}):")
     for addr in vault.allocators or ["(none)"]:
         tag = (
@@ -551,7 +551,7 @@ def _print_vault_v1(
         return
     rows: list[tuple[str, ...]] = []
     for alloc in allocations:
-        flow = vault.public_allocator_flow_caps.get(alloc.market_id.lower(), (0, 0))
+        flow = vault.public_allocator_flow_caps.get(alloc.market_id, (0, 0))
         flow_str = (
             f"in {_format_amount(flow[0], alloc.loan_decimals)}" if flow[0] else "—"
         )

{ipor_fusion-4.0.0.dev35 → ipor_fusion-4.0.0.dev39}/src/ipor_fusion/cli/vault_cmd.py

@@ -95,7 +95,7 @@ def vault() -> None:
     default=None,
     help="Chain ID or name (auto-detected when only one provider is configured).",
 )
-def add(address: str, label: str | None, chain_id: ChainId | None) -> None:
+def add(address: ChecksumAddress, label: str | None, chain_id: ChainId | None) -> None:
     """Save a vault to the config."""
     cfg = load_config()
 

{ipor_fusion-4.0.0.dev35 → ipor_fusion-4.0.0.dev39}/src/ipor_fusion/cli/vault_markets_view.py

@@ -53,7 +53,7 @@ def _print_lending_health(  # noqa: C901
         for pb in positions:
             coll_sym = resolve_token_symbol(ctx, pb.collateral_token) or "?"
             loan_sym = resolve_token_symbol(ctx, pb.loan_token) or "?"
-            click.echo(f"    morpho market 0x{pb.market_id} ({coll_sym}/{loan_sym}):")
+            click.echo(f"    morpho market {pb.market_id} ({coll_sym}/{loan_sym}):")
             click.echo(
                 f"      Collateral:    {_format_token_amount(ctx, int(pb.collateral), pb.collateral_token, prices)}"
             )

{ipor_fusion-4.0.0.dev35 → ipor_fusion-4.0.0.dev39}/src/ipor_fusion/market_info.py

@@ -34,7 +34,7 @@ def build_morpho_blue_market_json(
     market's parameters, state and rates (from `MorphoReader`), plus the
     MetaMorpho vaults supplying it when ``api_market`` (`fetch_market`) is
     given, or ``api_error`` when that lookup failed. ``market_id`` is the
-    64-hex-char id without ``0x``."""
+    canonical id (`parse_morpho_market_id`) and is written as is."""
     out: dict = {
         "market_id": market_id,
         "chain_id": chain_id,

{ipor_fusion-4.0.0.dev35 → ipor_fusion-4.0.0.dev39}/src/ipor_fusion/mcp/models.py

@@ -944,7 +944,7 @@ class MetaMorphoVaultResponse(_Base):
     allocations: list[dict[str, Any]] | None = None
     # shared
     owner: str
-    curator: str
+    curator: str | None = None
     allocators: list[str]
 
 

{ipor_fusion-4.0.0.dev35 → ipor_fusion-4.0.0.dev39}/src/ipor_fusion/mcp/server.py

@@ -464,7 +464,11 @@ def vault_add(
             save_config(cfg)
             return ActionResult(message=f"Vault {label} ({address}) updated.")
 
-    cfg.vaults.append(VaultEntry(address=address, label=label, chain_id=chain_id))
+    cfg.vaults.append(
+        VaultEntry(
+            address=Web3.to_checksum_address(address), label=label, chain_id=chain_id
+        )
+    )
     save_config(cfg)
     return ActionResult(message=f"Vault {label} ({address}) added.")
 

{ipor_fusion-4.0.0.dev35 → ipor_fusion-4.0.0.dev39}/src/ipor_fusion/morpho_api.py

@@ -14,6 +14,7 @@ from urllib.error import URLError
 from urllib.request import Request, urlopen
 
 from eth_abi import decode, encode
+from eth_typing import ChecksumAddress
 from eth_utils import keccak
 from web3 import Web3
 
@@ -97,7 +98,7 @@ class VaultFlowCap:
 class VaultAllocation:
     """A MetaMorpho vault's exposure to a single Morpho Blue market."""
 
-    vault_address: str
+    vault_address: ChecksumAddress
     vault_name: str
     vault_symbol: str
     asset_symbol: str
@@ -115,10 +116,10 @@ class MorphoApiMarket:
 
     market_id: MorphoBlueMarketId
     lltv: int
-    loan_token: str
+    loan_token: ChecksumAddress
     loan_symbol: str
     loan_decimals: int
-    collateral_token: str
+    collateral_token: ChecksumAddress
     collateral_symbol: str
     collateral_decimals: int
     oracle: str
@@ -179,13 +180,14 @@ def fetch_market(
 
 def _parse_market(raw: dict) -> MorphoApiMarket:
     state = raw.get("state") or {}
+    market_id = _api_market_id(raw.get("marketId"))
     return MorphoApiMarket(
-        market_id=_api_market_id(raw.get("marketId")),
+        market_id=market_id,
         lltv=int(raw["lltv"]),
-        loan_token=raw["loanAsset"]["address"],
+        loan_token=_api_address(raw["loanAsset"]["address"]),
         loan_symbol=raw["loanAsset"]["symbol"],
         loan_decimals=int(raw["loanAsset"]["decimals"]),
-        collateral_token=raw["collateralAsset"]["address"],
+        collateral_token=_api_address(raw["collateralAsset"]["address"]),
         collateral_symbol=raw["collateralAsset"]["symbol"],
         collateral_decimals=int(raw["collateralAsset"]["decimals"]),
         oracle=raw["oracle"]["address"],
@@ -198,9 +200,7 @@ def _parse_market(raw: dict) -> MorphoApiMarket:
         borrow_apy=float(state.get("borrowApy") or 0.0),
         fee_wad=int(state.get("fee") or 0),
         timestamp=int(state.get("timestamp") or 0),
-        vaults=[
-            _parse_vault(v, raw["marketId"]) for v in raw.get("supplyingVaults") or []
-        ],
+        vaults=[_parse_vault(v, market_id) for v in raw.get("supplyingVaults") or []],
     )
 
 
@@ -281,8 +281,8 @@ class VaultV2Cap:
     relative_cap_wad: int
     allocation: int
     market_id: MorphoBlueMarketId | None
-    loan_token: str | None
-    collateral_token: str | None
+    loan_token: ChecksumAddress | None
+    collateral_token: ChecksumAddress | None
     oracle: str | None
     irm: str | None
     lltv: int | None
@@ -297,20 +297,22 @@ class VaultV2Cap:
 class VaultV2Adapter:
     """An adapter contract attached to a Vault V2 (e.g. Morpho adapter)."""
 
-    address: str
+    address: ChecksumAddress
     adapter_type: str
     assets: int
-    inner_vault: str | None  # for MorphoVaultV2Adapter: the underlying market vault
+    inner_vault: (
+        ChecksumAddress | None
+    )  # for MorphoVaultV2Adapter: the underlying market vault
 
 
 @dataclass(slots=True)
 class VaultV2Info:
     """Snapshot of a Morpho Vault V2."""
 
-    address: str
+    address: ChecksumAddress
     name: str
     symbol: str
-    asset_address: str
+    asset_address: ChecksumAddress
     asset_symbol: str
     asset_decimals: int
     total_assets: int
@@ -319,13 +321,13 @@ class VaultV2Info:
     share_price: float
     max_apy: float
     performance_fee: float
-    performance_fee_recipient: str
+    performance_fee_recipient: ChecksumAddress | None
     management_fee: float
-    management_fee_recipient: str
-    owner: str
-    curator: str
-    allocators: list[str]
-    sentinels: list[str]
+    management_fee_recipient: ChecksumAddress | None
+    owner: ChecksumAddress
+    curator: ChecksumAddress | None
+    allocators: list[ChecksumAddress]
+    sentinels: list[ChecksumAddress]
     liquidity_adapter: VaultV2Adapter | None
     adapters: list[VaultV2Adapter]
     caps: list[VaultV2Cap] = field(default_factory=list)
@@ -355,22 +357,24 @@ class VaultV1MarketAllocation:
 class VaultV1Info:
     """Snapshot of a MetaMorpho V1 vault."""
 
-    address: str
+    address: ChecksumAddress
     name: str
     symbol: str
-    asset_address: str
+    asset_address: ChecksumAddress
     asset_symbol: str
     asset_decimals: int
     total_assets: int
     fee_wad: int
-    owner: str
-    curator: str
-    guardian: str
-    fee_recipient: str
-    allocators: list[str]
+    owner: ChecksumAddress
+    curator: ChecksumAddress | None
+    guardian: ChecksumAddress | None
+    fee_recipient: ChecksumAddress | None
+    allocators: list[ChecksumAddress]
     allocations: list[VaultV1MarketAllocation]
     public_allocator: VaultFlowCap | None  # vault-level (no flowCap filtering)
-    public_allocator_flow_caps: dict[str, tuple[int, int]]  # marketId -> (maxIn,maxOut)
+    public_allocator_flow_caps: dict[
+        MorphoBlueMarketId, tuple[int, int]
+    ]  # (maxIn, maxOut)
 
 
 def fetch_vault(
@@ -431,10 +435,10 @@ def _parse_vault_v2(raw: dict) -> VaultV2Info:
     ]
     caps = [_parse_v2_cap(c) for c in (raw.get("caps") or {}).get("items", []) if c]
     return VaultV2Info(
-        address=raw["address"],
+        address=_api_address(raw.get("address")),
         name=raw.get("name") or "",
         symbol=raw.get("symbol") or "",
-        asset_address=asset.get("address") or "",
+        asset_address=_api_address(asset.get("address")),
         asset_symbol=asset.get("symbol") or "",
         asset_decimals=int(asset.get("decimals") or 0),
         total_assets=int(raw.get("totalAssets") or 0),
@@ -443,18 +447,22 @@ def _parse_vault_v2(raw: dict) -> VaultV2Info:
         share_price=float(raw.get("sharePrice") or 0.0),
         max_apy=float(raw.get("maxApy") or 0.0),
         performance_fee=float(raw.get("performanceFee") or 0.0),
-        performance_fee_recipient=raw.get("performanceFeeRecipient") or "",
+        performance_fee_recipient=_api_optional_address(
+            raw.get("performanceFeeRecipient")
+        ),
         management_fee=float(raw.get("managementFee") or 0.0),
-        management_fee_recipient=raw.get("managementFeeRecipient") or "",
-        owner=(raw.get("owner") or {}).get("address") or "",
-        curator=(raw.get("curator") or {}).get("address") or "",
+        management_fee_recipient=_api_optional_address(
+            raw.get("managementFeeRecipient")
+        ),
+        owner=_api_address((raw.get("owner") or {}).get("address")),
+        curator=_api_optional_address((raw.get("curator") or {}).get("address")),
         allocators=[
-            a["allocator"]["address"]
+            _api_address(a["allocator"]["address"])
             for a in raw.get("allocators") or []
             if (a.get("allocator") or {}).get("address")
         ],
         sentinels=[
-            s["sentinel"]["address"]
+            _api_address(s["sentinel"]["address"])
             for s in raw.get("sentinels") or []
             if (s.get("sentinel") or {}).get("address")
         ],
@@ -466,10 +474,10 @@ def _parse_vault_v2(raw: dict) -> VaultV2Info:
 
 def _parse_v2_adapter(raw: dict) -> VaultV2Adapter:
     return VaultV2Adapter(
-        address=raw.get("address") or "",
+        address=_api_address(raw.get("address")),
         adapter_type=raw.get("type") or raw.get("__typename") or "",
         assets=int(raw.get("assets") or 0),
-        inner_vault=(raw.get("metaMorpho") or {}).get("address"),
+        inner_vault=_api_optional_address((raw.get("metaMorpho") or {}).get("address")),
     )
 
 
@@ -500,7 +508,10 @@ def _parse_v2_cap(raw: dict) -> VaultV2Cap:
 
 def _decode_market_v1_id_data(
     id_data: str,
-) -> tuple[str, str, str, str, int] | None:
+) -> (
+    tuple[ChecksumAddress, ChecksumAddress, ChecksumAddress, ChecksumAddress, int]
+    | None
+):
     """Decode a Vault V2 `MarketV1`-type cap idData into MarketParams.
 
     Vault V2 encodes the cap idData as `abi.encode(string idType, address adapter,
@@ -548,6 +559,16 @@ def _decode_market_v1_id_data(
     )
 
 
+def _api_address(value: object) -> ChecksumAddress:
+    if not isinstance(value, str) or not Web3.is_address(value):
+        raise MorphoApiError(f"Morpho API returned an invalid address: {value!r}")
+    return Web3.to_checksum_address(value)
+
+
+def _api_optional_address(value: object) -> ChecksumAddress | None:
+    return None if value is None or value == "" else _api_address(value)
+
+
 def _api_market_id(value: object) -> MorphoBlueMarketId:
     try:
         return parse_morpho_market_id(str(value or ""))
@@ -598,7 +619,7 @@ def _parse_vault_v1(raw: dict) -> VaultV1Info:
 
     pac = raw.get("publicAllocatorConfig")
     flow_cap_summary: VaultFlowCap | None = None
-    flow_caps: dict[str, tuple[int, int]] = {}
+    flow_caps: dict[MorphoBlueMarketId, tuple[int, int]] = {}
     if pac:
         flow_cap_summary = VaultFlowCap(
             fee_wei=int(pac.get("fee") or 0),
@@ -607,25 +628,29 @@ def _parse_vault_v1(raw: dict) -> VaultV1Info:
             admin=pac.get("admin"),
         )
         for fc in pac.get("flowCaps") or []:
-            mid = ((fc.get("market") or {}).get("marketId") or "").lower()
-            if mid:
-                flow_caps[mid] = (int(fc.get("maxIn") or 0), int(fc.get("maxOut") or 0))
+            if raw_mid := (fc.get("market") or {}).get("marketId"):
+                flow_caps[_api_market_id(raw_mid)] = (
+                    int(fc.get("maxIn") or 0),
+                    int(fc.get("maxOut") or 0),
+                )
 
     return VaultV1Info(
-        address=raw["address"],
+        address=_api_address(raw.get("address")),
         name=raw.get("name") or "",
         symbol=raw.get("symbol") or "",
-        asset_address=asset.get("address") or "",
+        asset_address=_api_address(asset.get("address")),
         asset_symbol=asset.get("symbol") or "",
         asset_decimals=int(asset.get("decimals") or 0),
         total_assets=int(state.get("totalAssets") or 0),
         fee_wad=int(state.get("fee") or 0),
-        owner=state.get("owner") or "",
-        curator=state.get("curator") or "",
-        guardian=state.get("guardian") or "",
-        fee_recipient=state.get("feeRecipient") or "",
+        owner=_api_address(state.get("owner")),
+        curator=_api_optional_address(state.get("curator")),
+        guardian=_api_optional_address(state.get("guardian")),
+        fee_recipient=_api_optional_address(state.get("feeRecipient")),
         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")
         ],
         allocations=allocations,
         public_allocator=flow_cap_summary,
@@ -633,27 +658,28 @@ def _parse_vault_v1(raw: dict) -> VaultV1Info:
     )
 
 
+def _is_market(entry: dict, market_id: MorphoBlueMarketId) -> bool:
+    """Whether an allocation or flow-cap ``entry`` names ``market_id``, in any
+    spelling the API returns."""
+    raw = (entry.get("market") or {}).get("marketId")
+    try:
+        return parse_morpho_market_id(str(raw or "")) == market_id
+    except ValueError:
+        return False
+
+
 def _parse_vault(raw: dict, market_id: MorphoBlueMarketId) -> VaultAllocation:
     asset = raw.get("asset") or {}
     state = raw.get("state") or {}
     allocation_for_market: dict = next(
-        (
-            a
-            for a in (state.get("allocation") or [])
-            if (a.get("market") or {}).get("marketId", "").lower() == market_id
-        ),
+        (a for a in (state.get("allocation") or []) if _is_market(a, market_id)),
         {},
     )
     pac = raw.get("publicAllocatorConfig")
     flow_cap: VaultFlowCap | None = None
     if pac:
         flow_for_market = next(
-            (
-                fc
-                for fc in (pac.get("flowCaps") or [])
-                if (fc.get("market") or {}).get("marketId", "").lower()
-                == market_id.lower()
-            ),
+            (fc for fc in (pac.get("flowCaps") or []) if _is_market(fc, market_id)),
             None,
         )
         if flow_for_market:
@@ -667,7 +693,7 @@ def _parse_vault(raw: dict, market_id: MorphoBlueMarketId) -> VaultAllocation:
         a["address"] for a in (raw.get("allocators") or []) if a.get("address")
     ]
     return VaultAllocation(
-        vault_address=raw["address"],
+        vault_address=_api_address(raw["address"]),
         vault_name=raw.get("name") or "",
         vault_symbol=raw.get("symbol") or "",
         asset_symbol=asset.get("symbol") or "",

{ipor_fusion-4.0.0.dev35 → ipor_fusion-4.0.0.dev39}/src/ipor_fusion/validation.py

@@ -98,7 +98,7 @@ class VaultState(Protocol):
     @property
     def block_timestamp(self) -> int: ...
     @property
-    def asset(self) -> str: ...
+    def asset(self) -> ChecksumAddress: ...
     @property
     def asset_symbol(self) -> str: ...
     @property
@@ -219,11 +219,11 @@ class VaultValidation:
     found. Raw amounts are in the underlying ``asset``'s decimals.
     """
 
-    vault: str
+    vault: ChecksumAddress
     chain_id: ChainId
     block_number: int
     block_timestamp: int
-    asset: str
+    asset: ChecksumAddress
     asset_symbol: str
     asset_decimals: int
     asset_price_usd: float | None

{ipor_fusion-4.0.0.dev35 → ipor_fusion-4.0.0.dev39}/src/ipor_fusion/vault_data.py

@@ -164,7 +164,7 @@ class VaultData:
     total_assets: int
     total_supply: int
     supply_cap: int
-    asset: str
+    asset: ChecksumAddress
     asset_symbol: str
     access_manager: str
     price_oracle_addr: str

{ipor_fusion-4.0.0.dev35 → ipor_fusion-4.0.0.dev39}/src/ipor_fusion/vault_info.py

@@ -505,7 +505,7 @@ def _morpho_breakdown_json(
     prices = data.token_prices_usd
     return [
         {
-            "morpho_market_id": "0x" + str(pb.market_id),
+            "morpho_market_id": pb.market_id,
             "collateral_symbol": resolve_token_symbol(ctx, pb.collateral_token) or None,
             "loan_symbol": resolve_token_symbol(ctx, pb.loan_token) or None,
             "collateral": _build_breakdown_amount_json(

{ipor_fusion-4.0.0.dev35 → ipor_fusion-4.0.0.dev39}/tests/test_cli_helpers.py

@@ -63,7 +63,11 @@ from ipor_fusion.readers.lending_health import (
 )
 from ipor_fusion.readers.morpho import MORPHO_BLUE_ADDRESSES, MorphoPositionBreakdown
 from ipor_fusion.substrates import decode_substrate, market_name
-from ipor_fusion.types import Amount, MarketId, MorphoBlueMarketId
+from ipor_fusion.types import (
+    Amount,
+    MarketId,
+    parse_morpho_market_id,
+)
 from ipor_fusion.validation import Erc20Holdings
 from ipor_fusion.vault_data import (
     FeeData,
@@ -86,6 +90,7 @@ from ipor_fusion.vault_info import (
     _build_dependency_graph_json,
     _build_fees_json,
     _build_share_price_json,
+    _morpho_breakdown_json,
     _partition_balance_fuses,
 )
 
@@ -1509,7 +1514,7 @@ _TOKEN_WETH = Web3.to_checksum_address("0x" + "33" * 20)
 
 def _morpho_breakdown(market_id: str = "ab" * 32):
     return MorphoPositionBreakdown(
-        market_id=MorphoBlueMarketId(market_id),
+        market_id=parse_morpho_market_id(market_id),
         loan_token=_TOKEN_USDC,
         collateral_token=_TOKEN_WETH,
         collateral=Amount(10 * 10**18),
@@ -1705,6 +1710,30 @@ class TestFetcherCollectors:
         assert 14 in out and 1 not in out
         assert len(out[14]) == 1
 
+    @patch("ipor_fusion.vault_info.resolve_token_decimals", return_value=18)
+    @patch("ipor_fusion.vault_info.resolve_token_symbol", return_value="WETH")
+    @patch("ipor_fusion.vault_data.resolve_token_decimals", return_value=18)
+    @patch("ipor_fusion.vault_data.resolve_token_symbol", return_value="WETH")
+    def test_collected_morpho_id_renders_with_one_prefix(
+        self, _sym, _dec, _view_sym, _view_dec, capsys
+    ):
+        (market_id,) = _collect_morpho_substrates({14: [bytes.fromhex("ab" * 32)]})[14]
+        breakdown = MorphoPositionBreakdown(
+            market_id=market_id,
+            loan_token=_TOKEN_USDC,
+            collateral_token=_TOKEN_WETH,
+            collateral=Amount(0),
+            borrow_assets=Amount(0),
+            supply_assets=Amount(0),
+        )
+        data = _make_data(morpho_positions={14: [breakdown]})
+        (entry,) = _morpho_breakdown_json(MagicMock(), data, [breakdown])
+        assert entry["morpho_market_id"] == "0x" + "ab" * 32
+        _print_lending_health(MagicMock(), data)
+        out = capsys.readouterr().out
+        assert f"morpho market 0x{'ab' * 32} " in out
+        assert "0x0x" not in out
+
     def test_collect_morpho_substrates_skips_wrong_length(self):
         bad = bytes.fromhex("aa" * 16)  # wrong length
         out = _collect_morpho_substrates({14: [bad]})

{ipor_fusion-4.0.0.dev35 → ipor_fusion-4.0.0.dev39}/tests/test_cli_market_morpho_blue.py

@@ -21,6 +21,7 @@ from ipor_fusion.morpho_api import (
     fetch_market,
     fetch_vault,
 )
+from ipor_fusion.types import parse_morpho_market_id
 
 MARKET_ID = "ad656d430bb3d8c1469bf45c8ad4ebae1b04be04757c69fa424eec78d7b3f4dc"
 LOAN_TOKEN = Web3.to_checksum_address("0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48")
@@ -381,6 +382,60 @@ class TestMorphoApiClient:
         assert vault.flow_cap.admin == ADMIN_ADDR
         assert vault.allocators == [PUBLIC_ALLOCATOR_ETH, ADMIN_ADDR]
 
+    def test_fetch_market_matches_allocations_in_any_spelling(self):
+        upper = "0x" + MARKET_ID.upper()
+        market = {"market": {"marketId": upper}}
+        body = {
+            "data": {
+                "marketById": {
+                    "marketId": upper,
+                    "lltv": "915000000000000000",
+                    "loanAsset": {
+                        "address": LOAN_TOKEN,
+                        "symbol": "USDC",
+                        "decimals": 6,
+                    },
+                    "collateralAsset": {
+                        "address": COLLATERAL_TOKEN,
+                        "symbol": "WOUSD",
+                        "decimals": 18,
+                    },
+                    "oracle": {"address": ORACLE},
+                    "irmAddress": IRM,
+                    "state": {},
+                    "supplyingVaults": [
+                        {
+                            "address": VAULT_ADDR,
+                            "symbol": "v",
+                            "name": "v",
+                            "asset": {"symbol": "USDC", "decimals": 6},
+                            "state": {
+                                "allocation": [
+                                    {**market, "supplyAssets": 123, "supplyCap": 456}
+                                ]
+                            },
+                            "publicAllocatorConfig": {
+                                "fee": 0,
+                                "flowCaps": [{**market, "maxIn": 7, "maxOut": 8}],
+                            },
+                        }
+                    ],
+                }
+            }
+        }
+        with patch("ipor_fusion.morpho_api.urlopen") as mock_open:
+            mock_resp = MagicMock()
+            mock_resp.read.return_value = json.dumps(body).encode()
+            mock_open.return_value.__enter__.return_value = mock_resp
+
+            result = fetch_market(parse_morpho_market_id(MARKET_ID), 1)
+
+        assert result.market_id == "0x" + MARKET_ID.lower()
+        vault = result.vaults[0]
+        assert (vault.supply_assets, vault.supply_cap) == (123, 456)
+        assert vault.flow_cap is not None
+        assert (vault.flow_cap.max_in, vault.flow_cap.max_out) == (7, 8)
+
     def test_fetch_market_handles_missing_market(self):
         with patch("ipor_fusion.morpho_api.urlopen") as mock_open:
             mock_resp = MagicMock()