ipor-fusion 4.0.0.dev330__tar.gz → 4.0.0.dev336__tar.gz

{ipor_fusion-4.0.0.dev330 → ipor_fusion-4.0.0.dev336}/PKG-INFO

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

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

{ipor_fusion-4.0.0.dev330 → ipor_fusion-4.0.0.dev336}/src/ipor_fusion/core/contract.py

@@ -19,6 +19,12 @@ T_co = TypeVar("T_co", covariant=True)
 U = TypeVar("U")
 
 
+class _AbiDecodeFailure(DecodingError):
+    """The cause `Call.decode` chains a ``decode_error`` translation from, so an
+    optional batch read can tell an undecodable answer (``None``) apart from any
+    other error a decoder raises."""
+
+
 # No ``slots=True``: on early 3.11 and 3.12 patch releases (3.11.1, 3.12.0 and
 # 3.12.1 checked) ``Call[int](...)`` on a slotted frozen generic dataclass
 # raises ``TypeError`` when typing sets ``__orig_class__`` on the instance.
@@ -122,7 +128,9 @@ class Call(Generic[T_co]):
         except DecodingError as exc:
             if self.decode_error is None:
                 raise
-            raise self.decode_error(exc) from exc
+            marker = _AbiDecodeFailure(str(exc))
+            marker.__cause__ = exc
+            raise self.decode_error(exc) from marker
         single: object = values[0] if len(values) == 1 else values
         if self.decoder is not None:
             return self.decoder(single)

{ipor_fusion-4.0.0.dev330 → ipor_fusion-4.0.0.dev336}/src/ipor_fusion/core/multicall.py

@@ -9,7 +9,7 @@ from web3 import Web3
 from web3.exceptions import ContractLogicError
 
 from ipor_fusion.core.context import Web3Context
-from ipor_fusion.core.contract import Call, ContractWrapper
+from ipor_fusion.core.contract import Call, ContractWrapper, _AbiDecodeFailure
 from ipor_fusion.errors import EmptyCallResultError
 
 T = TypeVar("T")
@@ -226,6 +226,13 @@ class Multicall3Batch:
             settle(result)
 
 
+def _translated_decode_failure(exc: Exception) -> bool:
+    """Whether ``exc`` is a `Call.decode_error` translation of an undecodable
+    answer: it names the failure for required reads, while an optional read of
+    the same answer is ``None``."""
+    return isinstance(exc.__cause__, _AbiDecodeFailure)
+
+
 def _try_decode(call: Call[T], ok: bool, data: bytes) -> T | None:
     if not ok or not data:
         return None
@@ -233,6 +240,10 @@ def _try_decode(call: Call[T], ok: bool, data: bytes) -> T | None:
         return call.decode(data)
     except DecodingError:
         return None
+    except Exception as exc:
+        if _translated_decode_failure(exc):
+            return None
+        raise
 
 
 def _try_call(call: Call[T], ctx: Web3Context) -> T | None:
@@ -240,3 +251,7 @@ def _try_call(call: Call[T], ctx: Web3Context) -> T | None:
         return call.call(ctx)
     except _CALL_FAILURES:
         return None
+    except Exception as exc:
+        if _translated_decode_failure(exc):
+            return None
+        raise

{ipor_fusion-4.0.0.dev330 → ipor_fusion-4.0.0.dev336}/src/ipor_fusion/fuses/hypercore.py

@@ -1,6 +1,5 @@
 """HyperCore fuses (market 55): a HyperEVM PlasmaVault trading on Hyperliquid
-Core through delegatecalled fuses. (The first HyperEVM test vault ran on
-market 54, since reassigned to the crosschain market.)
+Core through delegatecalled fuses.
 
 The vault is the Core account: the fuses read the HyperCore precompiles and
 queue CoreWriter actions from the vault's own address, so no external position

{ipor_fusion-4.0.0.dev330 → ipor_fusion-4.0.0.dev336}/src/ipor_fusion/market_ids.py

@@ -100,18 +100,11 @@ class IporFusionMarkets:
     # on other chains through an executor (Stargate/LayerZero or Chainlink
     # CCIP). Substrate type: CrosschainSubstrateLib (1 EXECUTOR, 2 REMOTE_VAULT
     # bound to a chain id).
-    # A legacy HyperEVM HyperCore test vault also uses 54 until it is
-    # redeployed on HyperCore's assigned market 55; do not interpret that
-    # vault's market-54 substrates as crosschain configuration.
     CROSSCHAIN = MarketId(54)
     # HyperCore market (id 55): a HyperEVM PlasmaVault trading on Hyperliquid
     # Core through delegatecalled fuses (CoreWriter actions, precompile reads).
     # Substrate type: HyperCoreSubstrateLib (1 SpotToken, 2 PerpMarket,
-    # 3 Destination, 4 Builder, 5 Config, 6 SendCap). Ahead of the public
-    # contracts repo; the mirror test allowlists it until the constant lands.
-    # The first HyperEVM test deployment ran on id 54 before the contracts
-    # team assigned 54 to crosschain and moved HyperCore to 55; that vault's
-    # market 54 is pre-renumbering HyperCore wiring, not a crosschain market.
+    # 3 Destination, 4 Builder, 5 Config, 6 SendCap, 7 PerpPositionCap).
     HYPERCORE = MarketId(55)
     # POL unstaking via sPOLController. The out-of-band id is baked into the
     # deployed fuses as an immutable (424243 = 0x67933), so it must match the

{ipor_fusion-4.0.0.dev330 → ipor_fusion-4.0.0.dev336}/src/ipor_fusion/preflight.py

@@ -141,8 +141,9 @@ def _market_id_call(fuse: FuseAddress) -> Call[MarketId]:
 
 
 def _pinned(ctx: Web3Context) -> tuple[Web3Context, int]:
-    default = ctx.default_block
-    block = default if isinstance(default, int) else ctx.web3.eth.block_number
+    """``ctx`` pinned to the number of the block it names (a number, hash or tag
+    such as ``finalized``), resolved once."""
+    block = int(ctx.web3.eth.get_block(ctx.default_block)["number"])
     return ctx.at_block(block), block
 
 
@@ -321,7 +322,8 @@ def preflight_execute(
     simulate: bool = True,
 ) -> ExecutePreflight:
     """Check ``actions`` as ``sender``'s `PlasmaVault.execute` on the state of one
-    base block (``ctx.default_block`` when it is a number, else the latest).
+    base block: the one ``ctx.default_block`` names (a number, hash or tag),
+    resolved once.
 
     The static checks take a few Multicall3 batches (one per dependency-graph
     level), the ``canCall`` read, the balance-fuse storage reads and, for a

{ipor_fusion-4.0.0.dev330 → ipor_fusion-4.0.0.dev336}/src/ipor_fusion/readers/hypercore.py

@@ -66,14 +66,13 @@ from ipor_fusion.types import (
 
 T = TypeVar("T")
 
-#: New HyperCore vaults use market 55; the abandoned pilot still keys 54.
+#: The HyperCore market id.
 HYPERCORE_MARKET = IporFusionMarkets.HYPERCORE
 #: The only chain with the HyperCore precompiles.
 HYPEREVM_CHAIN_ID = ChainId(999)
 #: ``HyperCorePendingReader`` per chain, as ``ipor-abi`` publishes it. The
 #: reader is a stateless helper the vault delegatecalls, so one deployment
-#: serves every vault of the same contracts build (a vault of the earlier
-#: build only while nothing is in flight: its hooks write no effect fields).
+#: serves every vault of the released contracts build.
 HYPERCORE_PENDING_READERS: dict[ChainId, ChecksumAddress] = {
     HYPEREVM_CHAIN_ID: Web3.to_checksum_address(
         "0x1EFFb12434f5fb59a636C54D8CBaC93b13DF1A9E"

{ipor_fusion-4.0.0.dev330 → ipor_fusion-4.0.0.dev336}/src/ipor_fusion/substrates.py

@@ -636,10 +636,8 @@ _register_markets([53], _decode_uniswap_v4)
 # Crosschain (54): EXECUTOR / REMOTE_VAULT typed substrates per
 # CrosschainSubstrateLib.sol.
 _register_markets([54], _decode_crosschain)
-# HyperCore (55): typed substrates per HyperCoreSubstrateLib.sol, verified
-# against the 12 words granted on the first HyperEVM test vault (see
-# tests/fixtures/hypercore_hip3_flow.json; that run used id 54 before the
-# renumbering). Numeric 54 is the crosschain market, registered above.
+# HyperCore (55): typed substrates per HyperCoreSubstrateLib.sol at the
+# release the official deployment was built from.
 _register_markets([55], _decode_hypercore)
 
 

{ipor_fusion-4.0.0.dev330 → ipor_fusion-4.0.0.dev336}/tests/test_multicall.py

@@ -370,3 +370,85 @@ class TestBatch:
             batch.run()
         assert [to for to, _ in seen] == [MULTICALL3_ADDRESS, TOKEN_B]
         assert {block for _, block in seen} == {TestPinnedContext.BLOCK}
+
+
+class TestNamedDecodeErrors:
+    """A Call whose decode_error names an undecodable answer (an earlier
+    dispatcher's six-word observation): required reads raise the named error,
+    optional reads are None, with Multicall3 and without it."""
+
+    DISPATCHER = Web3.to_checksum_address("0x" + "cc" * 20)
+    SIX_WORDS = encode(["uint256"] * 6, [1, 2, 3, 4, 5, 6])
+
+    def _observation(self) -> Call[object]:
+        from ipor_fusion.crosschain import CcipCrosschainDispatcher
+
+        return CcipCrosschainDispatcher(self.DISPATCHER).observation()
+
+    def _answer(self, _to: str, _data: bytes) -> bytes:
+        return self.SIX_WORDS
+
+    def _contexts(self) -> list[MagicMock]:
+        return [
+            _ctx(self._answer),
+            TestWithoutMulticall3._ctx_without_multicall(self._answer),
+        ]
+
+    def test_required_reads_raise_the_named_error(self):
+        from ipor_fusion.errors import UnsupportedContractVersionError
+
+        for ctx in self._contexts():
+            with pytest.raises(
+                UnsupportedContractVersionError, match="released 8-field"
+            ):
+                self._observation().call(ctx)
+            with pytest.raises(UnsupportedContractVersionError):
+                Multicall3(ctx).aggregate([self._observation()])
+            batch = Multicall3(ctx).batch()
+            batch.add(self._observation())
+            with pytest.raises(UnsupportedContractVersionError):
+                batch.run()
+
+    def test_optional_reads_are_none(self):
+        for ctx in self._contexts():
+            assert Multicall3(ctx).try_aggregate([self._observation()]) == [None]
+            batch = Multicall3(ctx).batch()
+            read = batch.try_add(self._observation())
+            mapped = batch.try_add(self._observation().map(lambda o: o))
+            batch.run()
+            assert (read.value, mapped.value) == (None, None)
+
+    def test_other_decoder_errors_still_propagate_from_optional_reads(self):
+        from eth_abi.exceptions import DecodingError
+
+        def buggy(_value: object) -> object:
+            raise ValueError("decoder bug") from DecodingError("inner")
+
+        def translate(exc: Exception) -> Exception:
+            return RuntimeError(f"named: {exc}")
+
+        valid = encode(["uint256"], [7])
+        decoded_badly = Call(
+            to=self.DISPATCHER,
+            data=SELECTOR,
+            output_types=["uint256"],
+            decoder=buggy,
+            decode_error=translate,
+        )
+        mapped_badly = Call(
+            to=self.DISPATCHER,
+            data=SELECTOR,
+            output_types=["uint256"],
+            decode_error=translate,
+        ).map(buggy)
+        for ctx in [
+            _ctx(lambda _to, _data: valid),
+            TestWithoutMulticall3._ctx_without_multicall(lambda _to, _data: valid),
+        ]:
+            for call in (decoded_badly, mapped_badly):
+                with pytest.raises(ValueError, match="decoder bug"):
+                    Multicall3(ctx).try_aggregate([call])
+                batch = Multicall3(ctx).batch()
+                batch.try_add(call)
+                with pytest.raises(ValueError, match="decoder bug"):
+                    batch.run()

{ipor_fusion-4.0.0.dev330 → ipor_fusion-4.0.0.dev336}/tests/test_preflight.py

@@ -85,7 +85,7 @@ def _ctx(
     ctx.chain_id = 8453
     ctx.at_block.return_value = ctx
     ctx.call.side_effect = multicall_aware(handler)
-    ctx.web3.eth.get_block.return_value = {"timestamp": NOW}
+    ctx.web3.eth.get_block.return_value = {"number": BLOCK, "timestamp": NOW}
     return ctx
 
 
@@ -231,6 +231,22 @@ class _FakeSimulator:
         return self.outcome
 
 
+@pytest.mark.parametrize("named", ["finalized", "safe", "0x" + "ab" * 32, "latest"])
+def test_the_block_the_context_names_is_resolved_and_pinned(monkeypatch, named):
+    monkeypatch.setattr(preflight_module, "is_simulate_v1_supported", lambda w3: True)
+    monkeypatch.setattr(preflight_module, "VaultSimulator", _FakeSimulator)
+    ctx = _ctx()
+    ctx.default_block = named
+
+    result = preflight_execute(ctx, VAULT, [_supply()], sender=SENDER)
+
+    ctx.web3.eth.get_block.assert_called_once_with(named)
+    ctx.at_block.assert_called_once_with(BLOCK)
+    # _FakeSimulator asserts it was built with block=BLOCK: the simulation
+    # runs on top of the resolved block, not the latest.
+    assert result.block_number == BLOCK
+
+
 def test_the_simulation_reports_total_assets_and_a_revert(monkeypatch):
     monkeypatch.setattr(preflight_module, "is_simulate_v1_supported", lambda w3: True)
     monkeypatch.setattr(preflight_module, "VaultSimulator", _FakeSimulator)