ipor-fusion 4.0.0.dev249__tar.gz → 4.0.0.dev255__tar.gz

{ipor_fusion-4.0.0.dev249 → ipor_fusion-4.0.0.dev255}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: ipor-fusion
-Version: 4.0.0.dev249
+Version: 4.0.0.dev255
 Summary: The IPOR Fusion SDK for Python
 Project-URL: homepage, https://ipor.io
 Project-URL: repository, https://github.com/IPOR-Labs/ipor-fusion.py
@@ -325,7 +325,7 @@ Reverts on the deploy-and-configure path, keyed by selector so a failed transact
 | `0x8745fbfd` | `DaoFeePackagesArrayEmpty()` | `clone()` was sent to `IporFusionFactoryImpl` | Send it to `IporFusionFactoryProxy` for that chain |
 | `0x9996b315` | `AddressEmptyCode(address)` | `execute()` touched a market with no balance fuse | `add_balance_fuse(market_id, balance_fuse)` before the first `execute` on that market |
 | `0x4bf4de4e` | `HandlerNotFound()` | A protocol called back into the vault during `execute()` (a flash loan) and no handler is registered for its address and selector | `update_callback_handler(handler, sender, selector)` before the first `execute` that triggers the callback |
-| `0x068ca9d8` | `AccessManagedUnauthorized(address)` | The caller lacks the role the function requires: `FUSE_MANAGER` for `add_fuses`, `grant_market_substrates`, `add_balance_fuse`, `update_callback_handler`; `ALPHA` for `execute`; `WHITELIST` for `deposit` and `mint` on a private vault | `AccessManager.grant_role(role, account, Period(0))` from the role's admin (`OWNER` grants `ATOMIST`, `ATOMIST` grants the rest); for a reverting `deposit`, whitelist the depositor or convert the vault to public |
+| `0x068ca9d8` | `AccessManagedUnauthorized(address)` | The caller lacks the role the function requires: `FUSE_MANAGER` for `add_fuses`, `grant_market_substrates`, `add_balance_fuse`, `update_callback_handler`; `ALPHA` for `execute`; `WHITELIST` for `deposit` and `mint` on a private vault | Check first with `AccessManager.can_call(caller, target, selector).call(ctx)` (a closed target or a missing role answers `immediate=False, delay=0`; a role with an execution delay answers its `delay`). `AccessManager.grant_role(role, account, Period(0))` from the role's admin (`OWNER` grants `ATOMIST`, `ATOMIST` grants the rest); for a reverting `deposit`, whitelist the depositor or convert the vault to public |
 | `ValueError: Private key required for sending transactions` | SDK, before any transaction | `.send(ctx)` on a `Web3Context` without a key | `Web3Context(w3, chain_id, signer=..., private_key=...)` or `Web3Context.from_url(url, private_key=...)` |
 
 `clone()` grants the owner only `Roles.OWNER_ROLE` (1). OWNER grants `Roles.ATOMIST_ROLE` (100), which administers `Roles.FUSE_MANAGER_ROLE` (300, configuration), `Roles.ALPHA_ROLE` (200, `execute`) and `Roles.WHITELIST_ROLE` (800, `deposit` on a private vault).

{ipor_fusion-4.0.0.dev249 → ipor_fusion-4.0.0.dev255}/README.md

@@ -277,7 +277,7 @@ Reverts on the deploy-and-configure path, keyed by selector so a failed transact
 | `0x8745fbfd` | `DaoFeePackagesArrayEmpty()` | `clone()` was sent to `IporFusionFactoryImpl` | Send it to `IporFusionFactoryProxy` for that chain |
 | `0x9996b315` | `AddressEmptyCode(address)` | `execute()` touched a market with no balance fuse | `add_balance_fuse(market_id, balance_fuse)` before the first `execute` on that market |
 | `0x4bf4de4e` | `HandlerNotFound()` | A protocol called back into the vault during `execute()` (a flash loan) and no handler is registered for its address and selector | `update_callback_handler(handler, sender, selector)` before the first `execute` that triggers the callback |
-| `0x068ca9d8` | `AccessManagedUnauthorized(address)` | The caller lacks the role the function requires: `FUSE_MANAGER` for `add_fuses`, `grant_market_substrates`, `add_balance_fuse`, `update_callback_handler`; `ALPHA` for `execute`; `WHITELIST` for `deposit` and `mint` on a private vault | `AccessManager.grant_role(role, account, Period(0))` from the role's admin (`OWNER` grants `ATOMIST`, `ATOMIST` grants the rest); for a reverting `deposit`, whitelist the depositor or convert the vault to public |
+| `0x068ca9d8` | `AccessManagedUnauthorized(address)` | The caller lacks the role the function requires: `FUSE_MANAGER` for `add_fuses`, `grant_market_substrates`, `add_balance_fuse`, `update_callback_handler`; `ALPHA` for `execute`; `WHITELIST` for `deposit` and `mint` on a private vault | Check first with `AccessManager.can_call(caller, target, selector).call(ctx)` (a closed target or a missing role answers `immediate=False, delay=0`; a role with an execution delay answers its `delay`). `AccessManager.grant_role(role, account, Period(0))` from the role's admin (`OWNER` grants `ATOMIST`, `ATOMIST` grants the rest); for a reverting `deposit`, whitelist the depositor or convert the vault to public |
 | `ValueError: Private key required for sending transactions` | SDK, before any transaction | `.send(ctx)` on a `Web3Context` without a key | `Web3Context(w3, chain_id, signer=..., private_key=...)` or `Web3Context.from_url(url, private_key=...)` |
 
 `clone()` grants the owner only `Roles.OWNER_ROLE` (1). OWNER grants `Roles.ATOMIST_ROLE` (100), which administers `Roles.FUSE_MANAGER_ROLE` (300, configuration), `Roles.ALPHA_ROLE` (200, `execute`) and `Roles.WHITELIST_ROLE` (800, `deposit` on a private vault).

{ipor_fusion-4.0.0.dev249 → ipor_fusion-4.0.0.dev255}/pyproject.toml

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

{ipor_fusion-4.0.0.dev249 → ipor_fusion-4.0.0.dev255}/src/ipor_fusion/__init__.py

@@ -26,6 +26,7 @@ from ipor_fusion.chains import (
 from ipor_fusion.config.roles import Roles
 from ipor_fusion.core.access import (
     AccessManager,
+    CallPermission,
     RoleAccount,
     RoleAccountJson,
     RoleAccountsJson,
@@ -464,6 +465,7 @@ __all__ = [
     "AccessManager",
     "RoleAccount",
     "RoleAccountJson",
+    "CallPermission",
     "RoleStatus",
     "resolve_access_manager",
     "role_account_sort_key",

{ipor_fusion-4.0.0.dev249 → ipor_fusion-4.0.0.dev255}/src/ipor_fusion/core/__init__.py

@@ -1,5 +1,6 @@
 from ipor_fusion.core.access import (
     AccessManager,
+    CallPermission,
     RoleAccount,
     RoleAccountJson,
     RoleAccountsJson,
@@ -92,6 +93,7 @@ __all__ = [
     "AccessManager",
     "RoleAccount",
     "RoleAccountJson",
+    "CallPermission",
     "RoleStatus",
     "RewardsManager",
     "VestingData",

{ipor_fusion-4.0.0.dev249 → ipor_fusion-4.0.0.dev255}/src/ipor_fusion/core/access.py

@@ -8,7 +8,7 @@ from eth_typing import ChecksumAddress
 from hexbytes import HexBytes
 from web3 import Web3
 from web3.exceptions import ContractLogicError
-from web3.types import LogReceipt
+from web3.types import LogReceipt, Timestamp
 
 from ipor_fusion.config.roles import Roles
 from ipor_fusion.core.context import Web3Context
@@ -48,6 +48,30 @@ class RoleStatus:
     execution_delay: Period
 
 
+@dataclass(frozen=True, slots=True)
+class CallPermission:
+    """`AccessManager.canCall`: whether ``caller`` may call ``selector`` on ``target``.
+
+    ``immediate`` is a call allowed now; a member with an execution delay gets
+    ``immediate=False`` and that ``delay`` (it must schedule the call first). A closed
+    target or a non-member answers ``(False, 0)``. This is the role check only: the
+    IPOR manager's redemption lock and the target's own logic can still revert.
+    """
+
+    immediate: bool
+    delay: Period
+
+    @property
+    def allowed(self) -> bool:
+        """Allowed now or after scheduling."""
+        return self.immediate or self.delay > 0
+
+
+def _call_permission_decoder(values: tuple[bool, int]) -> CallPermission:
+    immediate, delay = values
+    return CallPermission(immediate=immediate, delay=Period(delay))
+
+
 @dataclass(slots=True)
 class RoleAccount:
     """Account-role membership record returned by AccessManager queries."""
@@ -159,6 +183,38 @@ class AccessManager(ContractWrapper):
             decoder=_role_status_decoder,
         )
 
+    def can_call(
+        self, caller: ChecksumAddress, target: ChecksumAddress, selector: bytes
+    ) -> Call[CallPermission]:
+        """`canCall(caller, target, selector)`: the closed-target check, the
+        function's role and the caller's membership and delay in one read."""
+        return self._view(
+            "canCall(address,address,bytes4)",
+            caller,
+            target,
+            selector,
+            output_types=["bool", "uint32"],
+            decoder=_call_permission_decoder,
+        )
+
+    def is_target_closed(self, target: ChecksumAddress) -> Call[bool]:
+        """Whether the admin closed ``target``: every restricted call to it fails."""
+        return self._view(
+            "isTargetClosed(address)", target, output_types=["bool"], decoder=bool
+        )
+
+    def get_account_lock_time(self, account: ChecksumAddress) -> Call[Timestamp]:
+        """Unix time until which ``account``, as the caller, cannot withdraw, redeem
+        or transfer shares (IPOR redemption delay). A deposit, mint or
+        ``depositWithPermit`` sets it for its caller, not for the share receiver;
+        a time ``<= block.timestamp`` is unlocked."""
+        return self._view(
+            "getAccountLockTime(address)",
+            account,
+            output_types=["uint256"],
+            decoder=Timestamp,
+        )
+
     # ── Composite reads on ``ctx``: event replay + batched hasRole reads ───
 
     def read_owner(self, ctx: Web3Context) -> ChecksumAddress:

{ipor_fusion-4.0.0.dev249 → ipor_fusion-4.0.0.dev255}/src/ipor_fusion/readers/aave_v3.py

@@ -1,3 +1,4 @@
+from collections.abc import Sequence
 from dataclasses import dataclass
 
 from eth_typing import ChecksumAddress
@@ -174,26 +175,81 @@ class AaveV3Reader(ContractWrapper):
         zero when `asset` is not listed on this Pool.
         """
         tokens = self.reserve_tokens(asset).call(ctx)
-        reserve_tokens = (
-            tokens.a_token,
-            tokens.variable_debt_token,
-            tokens.stable_debt_token,
+        listed = _listed_tokens(tokens)
+        balances = Multicall3(ctx).aggregate(
+            [ERC20(token).balance_of(user) for token in listed]
         )
-        listed = [token for token in reserve_tokens if token.lower() != ZERO_ADDRESS]
-        balances = iter(
-            Multicall3(ctx).aggregate(
-                [ERC20(token).balance_of(user) for token in listed]
-            )
+        return _position_breakdown(
+            asset, tokens, dict(zip(listed, balances, strict=True))
         )
-        supply, variable_debt, stable_debt = (
-            next(balances) if token in listed else Amount(0) for token in reserve_tokens
+
+    def read_position_breakdowns(
+        self,
+        ctx: Web3Context,
+        assets: Sequence[ChecksumAddress],
+        user: ChecksumAddress,
+    ) -> list[AaveV3PositionBreakdown | None]:
+        """:meth:`read_position_breakdown` for every asset in two Multicall3 batches
+        (every reserve's tokens, then every balance), each one round trip per
+        batch size, or one read per call without Multicall3; in ``assets`` order.
+
+        ``None`` for an asset whose reserve data or a balance reverts, returns no
+        data or cannot be decoded; a transport error raises.
+        """
+        multicall = Multicall3(ctx)
+        reserves = multicall.try_aggregate([self.reserve_tokens(a) for a in assets])
+        listed = {
+            token
+            for tokens in reserves
+            if tokens is not None
+            for token in _listed_tokens(tokens)
+        }
+        ordered = sorted(listed)
+        read = multicall.try_aggregate(
+            [ERC20(token).balance_of(user) for token in ordered]
         )
-        return AaveV3PositionBreakdown(
-            asset=asset,
-            a_token=tokens.a_token,
-            variable_debt_token=tokens.variable_debt_token,
-            stable_debt_token=tokens.stable_debt_token,
-            supply=supply,
-            variable_debt=variable_debt,
-            stable_debt=stable_debt,
+        balances = {
+            token: balance
+            for token, balance in zip(ordered, read, strict=True)
+            if balance is not None
+        }
+        return [
+            _position_breakdown(asset, tokens, balances)
+            if tokens is not None
+            and all(token in balances for token in _listed_tokens(tokens))
+            else None
+            for asset, tokens in zip(assets, reserves, strict=True)
+        ]
+
+
+def _listed_tokens(tokens: AaveV3ReserveTokens) -> list[ChecksumAddress]:
+    return [
+        token
+        for token in (
+            tokens.a_token,
+            tokens.variable_debt_token,
+            tokens.stable_debt_token,
         )
+        if token.lower() != ZERO_ADDRESS
+    ]
+
+
+def _position_breakdown(
+    asset: ChecksumAddress,
+    tokens: AaveV3ReserveTokens,
+    balances: dict[ChecksumAddress, Amount],
+) -> AaveV3PositionBreakdown:
+    """A zero token address counts as a zero balance."""
+
+    def balance(token: ChecksumAddress) -> Amount:
+        return Amount(0) if token.lower() == ZERO_ADDRESS else balances[token]
+
+    return AaveV3PositionBreakdown(
+        asset=asset,
+        a_token=tokens.a_token,
+        variable_debt_token=tokens.variable_debt_token,
+        stable_debt_token=tokens.stable_debt_token,
+        supply=balance(tokens.a_token),
+        variable_debt=balance(tokens.variable_debt_token),
+        stable_debt=balance(tokens.stable_debt_token),
+    )

{ipor_fusion-4.0.0.dev249 → ipor_fusion-4.0.0.dev255}/src/ipor_fusion/readers/morpho.py

@@ -1,4 +1,5 @@
 import math
+from collections.abc import Sequence
 from dataclasses import dataclass
 
 from eth_abi import encode
@@ -225,22 +226,45 @@ class MorphoReader(ContractWrapper):
         market_read = batch.add(self.market(market_id))
         params_read = batch.add(self.market_params(market_id))
         batch.run()
-        pos, market, params = pos_read.value, market_read.value, params_read.value
-        borrow_assets = to_assets_up(
-            pos.borrow_shares, market.total_borrow_assets, market.total_borrow_shares
-        )
-        supply_assets = to_assets_down(
-            pos.supply_shares, market.total_supply_assets, market.total_supply_shares
-        )
-        return MorphoPositionBreakdown(
-            market_id=market_id,
-            loan_token=params.loan_token,
-            collateral_token=params.collateral_token,
-            collateral=pos.collateral,
-            borrow_assets=Amount(borrow_assets),
-            supply_assets=Amount(supply_assets),
+        return _position_breakdown(
+            market_id, pos_read.value, market_read.value, params_read.value
         )
 
+    def read_position_breakdowns(
+        self,
+        ctx: Web3Context,
+        market_ids: Sequence[MorphoBlueMarketId],
+        user: ChecksumAddress,
+    ) -> list[MorphoPositionBreakdown | None]:
+        """:meth:`read_position_breakdown` for every market in one Multicall3
+        batch (one round trip per batch size, or one read per call without
+        Multicall3), in ``market_ids`` order.
+
+        ``None`` for a market whose position, state or params read reverts,
+        returns no data or cannot be decoded; a transport error raises.
+        """
+        batch = Multicall3(ctx).batch()
+        reads = [
+            (
+                batch.try_add(self.position(market_id, user)),
+                batch.try_add(self.market(market_id)),
+                batch.try_add(self.market_params(market_id)),
+            )
+            for market_id in market_ids
+        ]
+        batch.run()
+        breakdowns: list[MorphoPositionBreakdown | None] = []
+        for market_id, (pos, market, params) in zip(market_ids, reads, strict=True):
+            if pos.value is None or market.value is None or params.value is None:
+                breakdowns.append(None)
+            else:
+                breakdowns.append(
+                    _position_breakdown(
+                        market_id, pos.value, market.value, params.value
+                    )
+                )
+        return breakdowns
+
     def market_params(self, market_id: MorphoBlueMarketId) -> Call[MorphoMarketParams]:
         return self._view(
             "idToMarketParams(bytes32)",
@@ -352,3 +376,31 @@ def _irm_borrow_rate_view(
         to=params.irm, data=selector + payload, output_types=["uint256"]
     )
     return call.call(ctx)
+
+
+def _position_breakdown(
+    market_id: MorphoBlueMarketId,
+    pos: MorphoPosition,
+    market: MorphoMarket,
+    params: MorphoMarketParams,
+) -> MorphoPositionBreakdown:
+    return MorphoPositionBreakdown(
+        market_id=market_id,
+        loan_token=params.loan_token,
+        collateral_token=params.collateral_token,
+        collateral=pos.collateral,
+        borrow_assets=Amount(
+            to_assets_up(
+                pos.borrow_shares,
+                market.total_borrow_assets,
+                market.total_borrow_shares,
+            )
+        ),
+        supply_assets=Amount(
+            to_assets_down(
+                pos.supply_shares,
+                market.total_supply_assets,
+                market.total_supply_shares,
+            )
+        ),
+    )

{ipor_fusion-4.0.0.dev249 → ipor_fusion-4.0.0.dev255}/src/ipor_fusion/vault_data.py

@@ -572,12 +572,17 @@ def _fetch_lending_reads(
         ),
     )
     morpho_unread: list[str] = []
-    morpho_positions = _fetch_morpho_positions(
-        ctx, pool, vault_addr, markets.market_substrates, morpho_unread
+    f_morpho = pool.submit(
+        _fetch_morpho_positions,
+        ctx,
+        vault_addr,
+        markets.market_substrates,
+        morpho_unread,
     )
     aave_positions = _fetch_aave_positions(
         ctx, pool, vault_addr, markets.aave_pools, markets.market_substrates
     )
+    morpho_positions = f_morpho.result()
     lending_health = f_health.result()
     return _LendingReads(
         lending_health=lending_health,

{ipor_fusion-4.0.0.dev249 → ipor_fusion-4.0.0.dev255}/src/ipor_fusion/vault_positions.py

@@ -51,7 +51,6 @@ def _collect_morpho_substrates(
 
 def _fetch_morpho_positions(
     ctx: Web3Context,
-    pool: ThreadPoolExecutor,
     vault_addr: ChecksumAddress,
     market_substrates: dict[MarketId, list[bytes]],
     unread: list[str],
@@ -62,35 +61,34 @@ def _fetch_morpho_positions(
     Each IPOR Morpho market (MORPHO_MARKET_IDS) can hold multiple morpho
     market_id substrates; each substrate has an independent position. The
     on-chain balance fuse reports a single netted number per IPOR market —
-    this helper exposes the three-way decomposition behind that number.
+    this helper exposes the three-way decomposition behind that number. Every
+    substrate of every market is read in one batch; a batch failure that
+    ``_safe_call`` suppresses (an RPC error or timeout) leaves them all unread.
     """
     per_market_substrates = _collect_morpho_substrates(market_substrates)
     if not per_market_substrates:
         return None
 
     reader = MorphoReader(morpho_blue_address(ctx.chain_id))
-    futures: dict[MarketId, list[Future[MorphoPositionBreakdown | None]]] = {
-        mid: [
-            pool.submit(
-                _safe_call,
-                lambda mid_hex=morpho_mid: reader.read_position_breakdown(
-                    ctx, mid_hex, vault_addr
-                ),
-            )
-            for morpho_mid in morpho_mids
-        ]
-        for mid, morpho_mids in per_market_substrates.items()
-    }
+    flat = [
+        morpho_mid
+        for morpho_mids in per_market_substrates.values()
+        for morpho_mid in morpho_mids
+    ]
+    reads = iter(
+        _safe_call(partial(reader.read_position_breakdowns, ctx, flat, vault_addr))
+        or [None] * len(flat)
+    )
 
     result: dict[MarketId, list[MorphoPositionBreakdown]] = {}
-    for mid, per_market in futures.items():
-        reads = [fut.result() for fut in per_market]
+    for mid, morpho_mids in per_market_substrates.items():
+        per_market = [next(reads) for _ in morpho_mids]
         unread += [
             f"Morpho position in market {morpho_mid}"
-            for morpho_mid, bd in zip(per_market_substrates[mid], reads, strict=True)
+            for morpho_mid, bd in zip(morpho_mids, per_market, strict=True)
             if bd is None
         ]
-        breakdowns = [bd for bd in reads if bd is not None]
+        breakdowns = [bd for bd in per_market if bd is not None]
         if breakdowns:
             result[mid] = breakdowns
     return result or None
@@ -165,8 +163,8 @@ def _fetch_aave_positions(
 
     The on-chain `getUserAccountData` aggregates all reserves into a single
     base-currency total — this helper exposes the per-asset decomposition.
-    Each market is read from its own Pool (`aave_pools`); markets without one
-    are skipped. Empty positions (vault allows the asset but holds none of it)
+    Each market is read from its own Pool (`aave_pools`), its assets in two
+    batches; markets without one are skipped. Empty positions (vault allows the asset but holds none of it)
     are dropped.
     """
     per_market_assets = {
@@ -177,24 +175,23 @@ def _fetch_aave_positions(
     if not per_market_assets:
         return None
 
-    readers = {mid: AaveV3Reader(aave_pools[mid]) for mid in per_market_assets}
-    futures: dict[MarketId, list[Future[AaveV3PositionBreakdown | None]]] = {
-        mid: [
-            pool.submit(
-                _safe_call,
-                partial(readers[mid].read_position_breakdown, ctx, asset, vault_addr),
-            )
-            for asset in assets
-        ]
+    futures: dict[MarketId, Future[list[AaveV3PositionBreakdown | None] | None]] = {
+        mid: pool.submit(
+            _safe_call,
+            partial(
+                AaveV3Reader(aave_pools[mid]).read_position_breakdowns,
+                ctx,
+                assets,
+                vault_addr,
+            ),
+        )
         for mid, assets in per_market_assets.items()
     }
 
     result: dict[MarketId, list[AaveV3PositionBreakdown]] = {}
-    for mid, per_market in futures.items():
+    for mid, future in futures.items():
         breakdowns = [
-            bd
-            for fut in per_market
-            if (bd := fut.result()) is not None and not bd.is_empty
+            bd for bd in future.result() or [] if bd is not None and not bd.is_empty
         ]
         if breakdowns:
             result[mid] = breakdowns

{ipor_fusion-4.0.0.dev249 → ipor_fusion-4.0.0.dev255}/tests/test_access_manager.py

@@ -11,10 +11,12 @@ from web3.exceptions import ContractLogicError
 # Top-level imports on purpose — they also exercise the __init__ exports.
 from ipor_fusion import (
     AccessManager,
+    CallPermission,
     ContractNotFoundError,
     NotPlasmaVaultError,
     OwnerNotFoundError,
     RoleAccount,
+    parse_access_manager_address,
     resolve_access_manager,
     role_account_sort_key,
 )
@@ -255,3 +257,47 @@ class TestResolveAccessManager:
 
         assert isinstance(manager, AccessManager)
         assert manager.address == MANAGER_ADDR
+
+
+SELECTOR = bytes.fromhex("6e553f65")  # deposit(uint256,address)
+
+
+class TestPermissionReads:
+    manager = AccessManager(parse_access_manager_address(MANAGER_ADDR))
+
+    def test_can_call_encodes_and_decodes(self):
+        call = self.manager.can_call(ALICE, VAULT_ADDR, SELECTOR)
+
+        selector = Web3.keccak(text="canCall(address,address,bytes4)")[:4]
+        assert call.calldata == selector + encode(
+            ["address", "address", "bytes4"], [ALICE, VAULT_ADDR, SELECTOR]
+        )
+        assert call.decode(encode(["bool", "uint32"], [True, 0])) == CallPermission(
+            immediate=True, delay=Period(0)
+        )
+
+    @pytest.mark.parametrize(
+        ("immediate", "delay", "allowed"),
+        [(True, 0, True), (False, 3600, True), (False, 0, False)],
+    )
+    def test_allowed_covers_scheduled_calls(self, immediate, delay, allowed):
+        permission = self.manager.can_call(ALICE, VAULT_ADDR, SELECTOR).decode(
+            encode(["bool", "uint32"], [immediate, delay])
+        )
+
+        assert permission.delay == delay
+        assert permission.allowed is allowed
+
+    def test_is_target_closed(self):
+        call = self.manager.is_target_closed(VAULT_ADDR)
+
+        assert call.calldata[:4] == Web3.keccak(text="isTargetClosed(address)")[:4]
+        assert call.decode(encode(["bool"], [True])) is True
+
+    def test_get_account_lock_time(self):
+        call = self.manager.get_account_lock_time(ALICE)
+
+        assert call.calldata == Web3.keccak(text="getAccountLockTime(address)")[
+            :4
+        ] + encode(["address"], [ALICE])
+        assert call.decode(encode(["uint256"], [1_700_000_000])) == 1_700_000_000

{ipor_fusion-4.0.0.dev249 → ipor_fusion-4.0.0.dev255}/tests/test_cli_helpers.py

@@ -1896,9 +1896,9 @@ class TestFetchAavePositions:
     @patch("ipor_fusion.vault_positions.AaveV3Reader")
     def test_drops_empty_breakdowns(self, mock_reader_cls):
         mock_reader = MagicMock()
-        mock_reader.read_position_breakdown.return_value = _aave_breakdown(
-            supply=0, variable_debt=0, stable_debt=0
-        )
+        mock_reader.read_position_breakdowns.return_value = [
+            _aave_breakdown(supply=0, variable_debt=0, stable_debt=0)
+        ]
         mock_reader_cls.return_value = mock_reader
 
         with ThreadPoolExecutor() as pool:
@@ -1914,7 +1914,7 @@ class TestFetchAavePositions:
     @patch("ipor_fusion.vault_positions.AaveV3Reader")
     def test_returns_breakdowns_for_active_positions(self, mock_reader_cls):
         mock_reader = MagicMock()
-        mock_reader.read_position_breakdown.return_value = _aave_breakdown(supply=42)
+        mock_reader.read_position_breakdowns.return_value = [_aave_breakdown(supply=42)]
         mock_reader_cls.return_value = mock_reader
 
         with ThreadPoolExecutor() as pool:
@@ -1933,8 +1933,8 @@ class TestFetchAavePositions:
         breakdown comes from that market's Pool, never another market's."""
         supply_in_pool = {pool: i for i, pool in enumerate(_AAVE_POOLS.values(), 1)}
         mock_reader_cls.side_effect = lambda aave_pool: MagicMock(
-            read_position_breakdown=MagicMock(
-                return_value=_aave_breakdown(supply=supply_in_pool[aave_pool])
+            read_position_breakdowns=MagicMock(
+                return_value=[_aave_breakdown(supply=supply_in_pool[aave_pool])]
             )
         )
 
@@ -1956,24 +1956,20 @@ class TestFetchAavePositions:
 class TestFetchMorphoPositions:
     @patch("ipor_fusion.vault_positions.MorphoReader")
     def test_returns_none_when_no_morpho_substrates(self, _mock_reader_cls):
-        with ThreadPoolExecutor() as pool:
-            result = _fetch_morpho_positions(MagicMock(), pool, _VAULT_ADDR, {}, [])
+        result = _fetch_morpho_positions(MagicMock(), _VAULT_ADDR, {}, [])
         assert result is None
 
     @patch("ipor_fusion.vault_positions.MorphoReader")
     def test_returns_breakdowns_for_morpho_substrates(self, mock_reader_cls):
         mock_reader = MagicMock()
-        mock_reader.read_position_breakdown.return_value = _morpho_breakdown()
+        mock_reader.read_position_breakdowns.return_value = [_morpho_breakdown()]
         mock_reader_cls.return_value = mock_reader
 
         ctx = MagicMock()
         ctx.chain_id = 42161
         morpho_sub = bytes.fromhex("ab" * 32)
-        with ThreadPoolExecutor() as pool:
-            unread: list[str] = []
-            result = _fetch_morpho_positions(
-                ctx, pool, _VAULT_ADDR, {14: [morpho_sub]}, unread
-            )
+        unread: list[str] = []
+        result = _fetch_morpho_positions(ctx, _VAULT_ADDR, {14: [morpho_sub]}, unread)
         assert result == {14: [_morpho_breakdown()]}
         assert unread == []
         # Arbitrum has its own Morpho deployment — never the Ethereum address.
@@ -1981,23 +1977,38 @@ class TestFetchMorphoPositions:
 
     @patch("ipor_fusion.vault_positions.MorphoReader")
     def test_a_failed_substrate_is_named_and_the_rest_kept(self, mock_reader_cls):
-        good, bad = bytes.fromhex("ab" * 32), bytes.fromhex("cd" * 32)
-
-        def read(_ctx, market_id, _vault):
-            if market_id.endswith("cd" * 32):
-                raise Web3RPCError("rate limited")
-            return _morpho_breakdown()
-
-        mock_reader_cls.return_value.read_position_breakdown.side_effect = read
+        good, bad, other = (bytes.fromhex(h * 32) for h in ("ab", "cd", "ef"))
+        mock_reader_cls.return_value.read_position_breakdowns.return_value = [
+            _morpho_breakdown(),
+            None,
+            _morpho_breakdown(),
+        ]
         ctx = MagicMock()
         ctx.chain_id = 42161
         unread: list[str] = []
-        with ThreadPoolExecutor() as pool:
-            result = _fetch_morpho_positions(
-                ctx, pool, _VAULT_ADDR, {14: [good, bad]}, unread
-            )
-        assert result == {14: [_morpho_breakdown()]}
+        result = _fetch_morpho_positions(
+            ctx, _VAULT_ADDR, {14: [good, bad, other]}, unread
+        )
+        assert result == {14: [_morpho_breakdown(), _morpho_breakdown()]}
         assert unread == [f"Morpho position in market 0x{'cd' * 32}"]
+        # One batch for every substrate, in order.
+        (_ctx, market_ids, _vault), _ = (
+            mock_reader_cls.return_value.read_position_breakdowns.call_args
+        )
+        assert market_ids == [f"0x{h * 32}" for h in ("ab", "cd", "ef")]
+
+    @patch("ipor_fusion.vault_positions.MorphoReader")
+    def test_a_transport_error_leaves_every_substrate_unread(self, mock_reader_cls):
+        mock_reader_cls.return_value.read_position_breakdowns.side_effect = (
+            Web3RPCError("rate limited")
+        )
+        ctx = MagicMock()
+        ctx.chain_id = 42161
+        unread: list[str] = []
+        subs = [bytes.fromhex("ab" * 32), bytes.fromhex("cd" * 32)]
+        result = _fetch_morpho_positions(ctx, _VAULT_ADDR, {14: subs}, unread)
+        assert result is None
+        assert unread == [f"Morpho position in market 0x{h * 32}" for h in ("ab", "cd")]
 
 
 class TestBreakdownTokenPrices: