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

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

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

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

{ipor_fusion-4.0.0.dev37 → ipor_fusion-4.0.0.dev41}/src/ipor_fusion/cli/market_cmd.py

@@ -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.dev37 → ipor_fusion-4.0.0.dev41}/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.dev37 → ipor_fusion-4.0.0.dev41}/src/ipor_fusion/crosschain/ccip/contracts.py

@@ -165,9 +165,12 @@ class CcipCrosschainExecutor(CrosschainExecutor):
             "lastRemoteStateVersion(uint256)", chain_id, output_types=["uint64"]
         )
 
-    def active_return(self, chain_id: ChainId) -> Call[bytes]:
+    def active_return(self, chain_id: ChainId) -> Call[OperationId]:
         return self._view(
-            "activeReturn(uint256)", chain_id, output_types=["bytes32"], decoder=bytes
+            "activeReturn(uint256)",
+            chain_id,
+            output_types=["bytes32"],
+            decoder=lambda v: OperationId(bytes(v)),
         )
 
     def active_command(self, chain_id: ChainId) -> Call[CommandId]:
@@ -194,11 +197,14 @@ class CcipCrosschainExecutor(CrosschainExecutor):
         every value-moving operation bumps to invalidate the active proposal."""
         return self._view("accountingEpoch(uint256)", chain_id, output_types=["uint64"])
 
-    def active_proposal_id(self, chain_id: ChainId) -> Call[int]:
+    def active_proposal_id(self, chain_id: ChainId) -> Call[ProposalId]:
         """``activeProposalId(uint256)``: the active balance proposal id for
         the chain, 0 when there is none."""
         return self._view(
-            "activeProposalId(uint256)", chain_id, output_types=["uint256"]
+            "activeProposalId(uint256)",
+            chain_id,
+            output_types=["uint256"],
+            decoder=ProposalId,
         )
 
     def attestation_anchor_principal(self, chain_id: ChainId) -> Call[Amount]:
@@ -233,7 +239,7 @@ class CcipCrosschainExecutor(CrosschainExecutor):
             "processedCcipMessage(bytes32)", message_id, output_types=["bool"]
         )
 
-    def propose_balance(self, observation: BalanceObservation) -> Call[int]:
+    def propose_balance(self, observation: BalanceObservation) -> Call[ProposalId]:
         """``BALANCE_PROPOSER`` only; ``settled_balance`` in local decimals.
 
         A write: ``.send()`` it, or ``.call()`` inside a simulation to preview
@@ -243,6 +249,7 @@ class CcipCrosschainExecutor(CrosschainExecutor):
             "proposeBalance(uint256,uint256,uint64,uint64,uint64,uint64,bytes32)",
             *observation.as_tuple(),
             output_types=["uint256"],
+            decoder=ProposalId,
         )
 
     def reject_balance_and_block(self, proposal_id: ProposalId) -> Call[None]:
@@ -285,9 +292,11 @@ class CcipCrosschainDispatcher(CrosschainDispatcher):
     def tracked_vaults_length(self) -> Call[int]:
         return self._view("trackedVaultsLength()", output_types=["uint256"])
 
-    def tracked_position_set_hash(self) -> Call[bytes]:
+    def tracked_position_set_hash(self) -> Call[PositionSetHash]:
         return self._view(
-            "trackedPositionSetHash()", output_types=["bytes32"], decoder=bytes
+            "trackedPositionSetHash()",
+            output_types=["bytes32"],
+            decoder=lambda v: PositionSetHash(bytes(v)),
         )
 
     def response_queue_head(self) -> Call[int]:

{ipor_fusion-4.0.0.dev37 → ipor_fusion-4.0.0.dev41}/src/ipor_fusion/crosschain/ccip/lane.py

@@ -22,7 +22,7 @@ from ipor_fusion.fuses.crosschain.ccip import (
     CcipCrosschainSupplyFuse,
     CcipSendParams,
 )
-from ipor_fusion.types import Amount, ChainId
+from ipor_fusion.types import Amount, ChainId, ProposalId
 
 
 class CcipLane(CrosschainLane):
@@ -134,7 +134,7 @@ class CcipLane(CrosschainLane):
             lambda observation: _to_lane(observation, rate)
         )
 
-    def propose_balance(self, observation: BalanceObservation) -> Call[int]:
+    def propose_balance(self, observation: BalanceObservation) -> Call[ProposalId]:
         """Returns the proposal id (the function's return value)."""
         self._require_spoke(observation)
         return self.executor.propose_balance(observation)

{ipor_fusion-4.0.0.dev37 → ipor_fusion-4.0.0.dev41}/src/ipor_fusion/crosschain/contracts.py

@@ -76,8 +76,10 @@ class CrosschainExecutor(ContractWrapper):
     def asset(self) -> Call[ChecksumAddress]:
         return self._view("ASSET()", output_types=["address"], decoder=_address)
 
-    def asset_id(self) -> Call[bytes]:
-        return self._view("ASSET_ID()", output_types=["bytes32"], decoder=bytes)
+    def asset_id(self) -> Call[AssetId]:
+        return self._view(
+            "ASSET_ID()", output_types=["bytes32"], decoder=lambda v: AssetId(bytes(v))
+        )
 
     def factory(self) -> Call[ChecksumAddress]:
         return self._view("FACTORY()", output_types=["address"], decoder=_address)
@@ -172,8 +174,10 @@ class CrosschainDispatcher(ContractWrapper):
     def asset(self) -> Call[ChecksumAddress]:
         return self._view("ASSET()", output_types=["address"], decoder=_address)
 
-    def asset_id(self) -> Call[bytes]:
-        return self._view("ASSET_ID()", output_types=["bytes32"], decoder=bytes)
+    def asset_id(self) -> Call[AssetId]:
+        return self._view(
+            "ASSET_ID()", output_types=["bytes32"], decoder=lambda v: AssetId(bytes(v))
+        )
 
     def factory(self) -> Call[ChecksumAddress]:
         return self._view("FACTORY()", output_types=["address"], decoder=_address)

{ipor_fusion-4.0.0.dev37 → ipor_fusion-4.0.0.dev41}/src/ipor_fusion/crosschain/stargate/contracts.py

@@ -170,9 +170,12 @@ class StargateCrosschainExecutor(CrosschainExecutor):
             "pendingTransferCount(uint256)", chain_id, output_types=["uint256"]
         )
 
-    def pending_request_by_chain(self, chain_id: ChainId) -> Call[int]:
+    def pending_request_by_chain(self, chain_id: ChainId) -> Call[DeploymentRequestId]:
         return self._view(
-            "pendingRequestByChain(uint256)", chain_id, output_types=["uint256"]
+            "pendingRequestByChain(uint256)",
+            chain_id,
+            output_types=["uint256"],
+            decoder=DeploymentRequestId,
         )
 
     def active_command(self, chain_id: ChainId) -> Call[ActiveCommand]:
@@ -191,9 +194,12 @@ class StargateCrosschainExecutor(CrosschainExecutor):
             decoder=_active_command_decoder,
         )
 
-    def active_proposal_id(self, chain_id: ChainId) -> Call[int]:
+    def active_proposal_id(self, chain_id: ChainId) -> Call[ProposalId]:
         return self._view(
-            "activeProposalId(uint256)", chain_id, output_types=["uint256"]
+            "activeProposalId(uint256)",
+            chain_id,
+            output_types=["uint256"],
+            decoder=ProposalId,
         )
 
     def last_approval_at(self, chain_id: ChainId) -> Call[int]:

{ipor_fusion-4.0.0.dev37 → ipor_fusion-4.0.0.dev41}/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.dev37 → ipor_fusion-4.0.0.dev41}/src/ipor_fusion/morpho_api.py

@@ -180,8 +180,9 @@ 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=_api_address(raw["loanAsset"]["address"]),
         loan_symbol=raw["loanAsset"]["symbol"],
@@ -199,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 []],
     )
 
 
@@ -373,7 +372,9 @@ class VaultV1Info:
     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(
@@ -618,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),
@@ -627,9 +628,11 @@ 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=_api_address(raw.get("address")),
@@ -655,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:

{ipor_fusion-4.0.0.dev37 → ipor_fusion-4.0.0.dev41}/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.dev37 → ipor_fusion-4.0.0.dev41}/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.dev37 → ipor_fusion-4.0.0.dev41}/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()

{ipor_fusion-4.0.0.dev37 → ipor_fusion-4.0.0.dev41}/tests/test_crosschain_lane.py

@@ -803,3 +803,17 @@ class TestDeploymentDiscovery:
         ccip = next(lane for lane in lanes if isinstance(lane, CcipLane))
         assert ccip.route == ROUTE and ccip.fuses == CCIP_FUSES
         assert ccip.decimal_conversion_rate == DECIMAL_CONVERSION_RATE
+
+
+def test_id_getters_decode_into_the_types_their_writes_take():
+    ccip = CcipCrosschainExecutor(MagicMock(), EXECUTOR)
+    stargate = StargateCrosschainExecutor(MagicMock(), EXECUTOR)
+    word = encode(["bytes32"], [b"\x01" * 32])
+    number = encode(["uint256"], [7])
+    chain = ChainId(1)
+    assert ccip.active_return(chain).decode(word) == b"\x01" * 32
+    assert ccip.asset_id().decode(word) == b"\x01" * 32
+    assert ccip.active_proposal_id(chain).decode(number) == 7
+    assert stargate.active_proposal_id(chain).decode(number) == 7
+    assert stargate.pending_request_by_chain(chain).decode(number) == 7
+    assert type(ccip.asset_id().decode(word)) is bytes

{ipor_fusion-4.0.0.dev37 → ipor_fusion-4.0.0.dev41}/tests/typed_client/consumer.py

@@ -26,11 +26,20 @@ from ipor_fusion.chains import ensure_supported_chain
 from ipor_fusion.core.access import AccessManager
 from ipor_fusion.core.context import Web3Context
 from ipor_fusion.core.plasma_vault import PlasmaVault
+from ipor_fusion.crosschain.ccip.contracts import (
+    CcipCrosschainDispatcher,
+    CcipCrosschainExecutor,
+    CcipCrosschainFactory,
+)
 from ipor_fusion.crosschain.contracts import (
     CrosschainDispatcher,
     CrosschainExecutor,
     CrosschainFactory,
 )
+from ipor_fusion.crosschain.stargate.contracts import (
+    StargateCrosschainExecutor,
+    StargateCrosschainFactory,
+)
 from ipor_fusion.explorer import get_contract_name
 from ipor_fusion.morpho_api import fetch_market, fetch_vault
 from ipor_fusion.readers.morpho import morpho_blue_address
@@ -86,3 +95,23 @@ def crosschain(
     executor.approve_balance(ProposalId(1))
     dispatcher.command_status(CommandId(bytes(32)))
     factory.asset_frozen(AssetId(bytes(32)))
+
+
+def crosschain_reads_feed_writes(
+    ccip: CcipCrosschainExecutor,
+    ccip_dispatcher: CcipCrosschainDispatcher,
+    ccip_factory: CcipCrosschainFactory,
+    stargate: StargateCrosschainExecutor,
+    stargate_factory: StargateCrosschainFactory,
+) -> None:
+    # Ids read through the SDK go back in without re-wrapping.
+    ccip.approve_balance(ccip.active_proposal_id(ETHEREUM).call())
+    stargate.approve_balance(stargate.active_proposal_id(ETHEREUM).call())
+    ccip_factory.asset_frozen(ccip.asset_id().call())
+    ccip_factory.asset_config(ccip_dispatcher.asset_id().call())
+    stargate_factory.asset_config(stargate.asset_id().call())
+    ccip_dispatcher.processed_operation(ccip.active_return(ETHEREUM).call())
+    stargate.deployment_status(stargate.pending_request_by_chain(ETHEREUM).call())
+    stargate_factory.cancel_pending_deployment(
+        stargate.pending_request_by_chain(ETHEREUM).call()
+    )