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

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

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

@@ -1,6 +1,6 @@
 [project]
 name = "ipor-fusion"
-version = "4.0.0.dev330"
+version = "4.0.0.dev334"
 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.dev334}/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.dev334}/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.dev334}/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.dev334}/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.dev334}/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)