ipor-fusion 4.0.0.dev272__tar.gz → 4.0.0.dev274__tar.gz

{ipor_fusion-4.0.0.dev272 → ipor_fusion-4.0.0.dev274}/PKG-INFO

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

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

{ipor_fusion-4.0.0.dev272 → ipor_fusion-4.0.0.dev274}/src/ipor_fusion/readers/hypercore.py

@@ -30,7 +30,7 @@ from dataclasses import dataclass
 from enum import IntEnum
 from typing import TypeVar
 
-from eth_abi import encode
+from eth_abi import decode, encode
 from eth_typing import ChecksumAddress
 from eth_utils import function_signature_to_4byte_selector
 from web3 import Web3
@@ -41,7 +41,7 @@ from ipor_fusion.core.contract import Call
 from ipor_fusion.core.multicall import Multicall3
 from ipor_fusion.core.oracle import PriceOracleMiddleware
 from ipor_fusion.core.plasma_vault import PlasmaVault
-from ipor_fusion.errors import HyperCoreValuationError
+from ipor_fusion.errors import HyperCoreValuationError, UnsupportedContractVersionError
 from ipor_fusion.fuses.hypercore import (
     NATIVE_PERP_DEX,
     SUPPORTED_HIP3_DEXES,
@@ -71,13 +71,17 @@ T = TypeVar("T")
 HYPERCORE_MARKET = IporFusionMarkets.HYPERCORE
 #: The only chain with the HyperCore precompiles.
 HYPEREVM_CHAIN_ID = ChainId(999)
-#: Known ``HyperCorePendingReader`` deployments per chain. The reader is a
-#: stateless helper and any deployment serves any vault. The market-55 reader
-#: is pinned in ``tests/fixtures/hypercore_market55.json`` until ``ipor-abi``
-#: publishes it.
+#: The ``HyperCorePendingReader`` ``ipor-abi`` lists per chain. The reader
+#: runs the pending-action library in the vault's storage, so it must come from
+#: the build of the vault's HyperCore fuses and pre-hooks. A vault deployed
+#: before that build (the HyperEVM market-55 vault
+#: ``0xB8De01Ca5ca57A14671E1c696337134a02B4A478``) needs its own reader,
+#: ``0x83F54bc9eA4Dd19cb579Daa70368562C7a7534C4``, passed explicitly: the current
+#: one reads its storage the same but settles its reported-mode orders by time
+#: alone.
 HYPERCORE_PENDING_READERS: dict[ChainId, ChecksumAddress] = {
     HYPEREVM_CHAIN_ID: Web3.to_checksum_address(
-        "0x83F54bc9eA4Dd19cb579Daa70368562C7a7534C4"
+        "0x1EFFb12434f5fb59a636C54D8CBaC93b13DF1A9E"
     ),
 }
 WAD_DECIMALS = 18
@@ -363,22 +367,58 @@ class HyperCorePendingState:
     l1_block_available: bool
 
 
-_PENDING_ACTION_TYPE = "(uint64,uint64,uint64,uint8,uint8,uint8,uint64,uint24,bytes32,bool,uint256,uint256)"
-PENDING_STATE_TYPE = f"({_PENDING_ACTION_TYPE},bool,bool,bool,uint64,uint64,bool)"
+_PENDING_ACTION_PREFIX = (
+    "uint64,uint64,uint64,uint8,uint8,uint8,uint64,uint24,bytes32,bool,uint256,uint256"
+)
+_PENDING_ACTION_TYPE = (
+    f"({_PENDING_ACTION_PREFIX},uint8,uint64,address,uint64,uint256,uint64)"
+)
+#: ``pendingState()`` of the current reader.
+PENDING_STATE_TYPE = f"({_PENDING_ACTION_TYPE},bool,bool,uint64,uint64,bool)"
+#: ``pendingState()`` of the earlier reader: the 12-field struct and a
+#: ``refreshing`` predicate. Both tuples are static, so the payload length
+#: tells the two apart.
+LEGACY_PENDING_STATE_TYPE = (
+    f"(({_PENDING_ACTION_PREFIX}),bool,bool,bool,uint64,uint64,bool)"
+)
+_PENDING_STATE_SIZE = 23 * 32
+_LEGACY_PENDING_STATE_SIZE = 18 * 32
 _PENDING_STATE_SELECTOR = function_signature_to_4byte_selector("pendingState()")
-_IS_PENDING_SELECTOR = function_signature_to_4byte_selector("isPending()")
 
 
 # pendingUntil, enqueuedL1Block, enqueuedEvmBlock, actionClass, settlementMode,
 # reportedResult, resultL1Block, actionId, payloadHash, stateRefreshing,
-# cachedValueWad, actionNonce.
+# cachedValueWad, actionNonce: the struct prefix both readers share.
 _PendingAction = tuple[int, int, int, int, int, int, int, int, bytes, bool, int, int]
 
 
-def _decode_pending_state(
-    values: tuple[_PendingAction, bool, bool, bool, int, int, bool],
+def _decode_pending_payload(data: bytes) -> HyperCorePendingState:
+    if len(data) == _PENDING_STATE_SIZE:
+        state, pending, settled, l1_block, timestamp, l1_available = decode(
+            [PENDING_STATE_TYPE], data
+        )[0]
+        refreshing = False
+    elif len(data) == _LEGACY_PENDING_STATE_SIZE:
+        state, pending, settled, refreshing, l1_block, timestamp, l1_available = decode(
+            [LEGACY_PENDING_STATE_TYPE], data
+        )[0]
+    else:
+        raise UnsupportedContractVersionError(
+            f"HyperCorePendingReader.pendingState() returned {len(data)} bytes, "
+            f"not {_PENDING_STATE_SIZE} or {_LEGACY_PENDING_STATE_SIZE}"
+        )
+    return _pending_state(
+        state[:12],
+        (bool(pending), bool(settled), bool(refreshing)),
+        (l1_block, timestamp, bool(l1_available)),
+    )
+
+
+def _pending_state(
+    state: _PendingAction,
+    predicates: tuple[bool, bool, bool],
+    l1: tuple[int, int, bool],
 ) -> HyperCorePendingState:
-    state, pending, settled, refreshing, l1_block, timestamp, l1_available = values
     (
         pending_until,
         enqueued_l1_block,
@@ -393,6 +433,8 @@ def _decode_pending_state(
         cached_value_wad,
         action_nonce,
     ) = state
+    pending, settled, refreshing = predicates
+    l1_block, timestamp, l1_available = l1
     return HyperCorePendingState(
         pending_until=Timestamp(pending_until),
         enqueued_l1_block=enqueued_l1_block,
@@ -403,22 +445,23 @@ def _decode_pending_state(
         result_l1_block=result_l1_block,
         action_id=HyperCoreActionId(action_id),
         payload_hash=PayloadHash(bytes(payload_hash)),
-        refreshing=bool(refreshing or state_refreshing),
+        refreshing=refreshing or bool(state_refreshing),
         cached_value_wad=cached_value_wad,
         action_nonce=action_nonce,
-        pending=bool(pending),
-        settled=bool(settled),
+        pending=pending,
+        settled=settled,
         current_l1_block=l1_block,
         current_timestamp=Timestamp(timestamp),
-        l1_block_available=bool(l1_available),
+        l1_block_available=l1_available,
     )
 
 
 class HyperCorePendingReader:
     """``HyperCorePendingReader`` through the vault's ``UniversalReader``.
 
-    ``reader`` is the deployed helper (one per chain, never called directly);
-    the vault delegatecalls it so it sees the vault's pending slot. Keepers
+    ``reader`` is the deployed helper from the vault's build (never called
+    directly; see :data:`HYPERCORE_PENDING_READERS`); the vault delegatecalls
+    it so it sees the vault's pending slot. Keepers
     gate every action on :meth:`is_pending`: the pending-action pre-hook
     reverts ``execute`` and ``updateMarketsBalances`` while it is true.
     """
@@ -428,17 +471,17 @@ class HyperCorePendingReader:
         self._reader = reader
 
     def pending_state(self) -> Call[HyperCorePendingState]:
-        return self._vault.universal_read_decoded(
-            self._reader,
-            _PENDING_STATE_SELECTOR,
-            output_types=[PENDING_STATE_TYPE],
-            decoder=_decode_pending_state,
+        """``pendingState()`` of either reader build, told apart by the
+        payload length."""
+        return self._vault.universal_read(self._reader, _PENDING_STATE_SELECTOR).map(
+            _decode_pending_payload
         )
 
     def is_pending(self) -> Call[bool]:
-        return self._vault.universal_read_decoded(
-            self._reader, _IS_PENDING_SELECTOR, output_types=["bool"], decoder=bool
-        )
+        """The ``pending`` predicate of :meth:`pending_state`: the readers
+        name the standalone getter differently (``isPending()`` /
+        ``isActionPending()``)."""
+        return self.pending_state().map(lambda state: state.pending)
 
 
 def convert_to_wad_int(value: int, decimals: int) -> int:

{ipor_fusion-4.0.0.dev272 → ipor_fusion-4.0.0.dev274}/tests/test_hypercore_deployment.py

@@ -10,7 +10,6 @@ from web3 import Web3
 from ipor_fusion import PlasmaVault
 from ipor_fusion.core.context import Web3Context
 from ipor_fusion.hypercore import HyperCoreSubstrates
-from ipor_fusion.readers.hypercore import HYPERCORE_PENDING_READERS
 from ipor_fusion.types import MarketId
 
 FIXTURE = json.loads(
@@ -19,11 +18,6 @@ FIXTURE = json.loads(
 FUSE_NAMES = frozenset(name for name in FIXTURE["contracts"] if name.endswith("Fuse"))
 
 
-def test_default_pending_reader_matches_broadcast() -> None:
-    expected = FIXTURE["contracts"]["HyperCorePendingReader"]["address"]
-    assert HYPERCORE_PENDING_READERS[FIXTURE["chain_id"]] == expected
-
-
 def _read_address(web3: Web3, target: str, signature: str, block: int) -> str:
     result = web3.eth.call(
         {"to": target, "data": Web3.keccak(text=signature)[:4]},

{ipor_fusion-4.0.0.dev272 → ipor_fusion-4.0.0.dev274}/tests/test_hypercore_live.py

@@ -34,6 +34,7 @@ from ipor_fusion.fuses.hypercore import (
     precompile_index_of,
 )
 from ipor_fusion.hypercore import (
+    HYPERCORE_PENDING_READERS,
     HyperCoreCancelFuse,
     HyperCoreDepositFuse,
     HyperCoreOrderFuse,
@@ -125,6 +126,21 @@ def test_pending_state_reads_through_the_vault(
     assert state.pending or state.settled
 
 
+def test_both_reader_builds_read_the_same_pending_slot(
+    ctx: Web3Context, pending: HyperCorePendingReader
+):
+    legacy = pending.pending_state().call(ctx)
+    current = (
+        HyperCorePendingReader(VAULT, HYPERCORE_PENDING_READERS[999])
+        .pending_state()
+        .call(ctx)
+    )
+    shared = ("action_nonce", "action_class", "pending_until", "cached_value_wad")
+    assert [getattr(current, f) for f in shared] == [getattr(legacy, f) for f in shared]
+    assert current.payload_hash == legacy.payload_hash
+    assert current.l1_block_available and current.current_l1_block > 0
+
+
 def test_precompiles_batch_through_multicall3(ctx: Web3Context):
     reader = HyperCoreReader()
     nvda = precompile_index_of(XYZ_NVDA)

{ipor_fusion-4.0.0.dev272 → ipor_fusion-4.0.0.dev274}/tests/test_hypercore_readers.py

@@ -14,7 +14,11 @@ from eth_utils import function_signature_to_4byte_selector
 from web3 import Web3
 from web3.exceptions import ContractLogicError
 
-from ipor_fusion import HyperCoreValuationError, PlasmaVault
+from ipor_fusion import (
+    HyperCoreValuationError,
+    PlasmaVault,
+    UnsupportedContractVersionError,
+)
 from ipor_fusion.hypercore import (
     HyperCoreActionClass,
     HyperCoreNav,
@@ -32,6 +36,7 @@ from ipor_fusion.readers.hypercore import (
     ACCOUNT_MARGIN_SUMMARY_PRECOMPILE,
     CORE_USER_EXISTS_PRECOMPILE,
     L1_BLOCK_NUMBER_PRECOMPILE,
+    LEGACY_PENDING_STATE_TYPE,
     PENDING_STATE_TYPE,
     PERP_ASSET_INFO_PRECOMPILE,
     POSITION_PRECOMPILE,
@@ -154,32 +159,47 @@ class TestPrecompileCalls:
             self.reader.perp_asset_info(1 << 32)
 
 
-def _pending_state_raw(*, pending: bool, settled: bool) -> bytes:
-    state = (
-        1_790_609_642,
-        1_164_341_828,
-        47_125_670,
-        1,  # Transfer
-        0,  # settlement mode unset for a transfer
-        0,
-        0,
-        13,  # sendAsset
-        b"\x30" * 32,
-        False,
-        10**16,
-        32,
-    )
-    inner = encode(
-        [PENDING_STATE_TYPE],
-        [(state, pending, settled, False, 1_168_823_034, 1_790_931_001, True)],
-    )
+_STATE_PREFIX = (
+    1_790_609_642,
+    1_164_341_828,
+    47_125_670,
+    1,  # Transfer
+    0,  # settlement mode unset for a transfer
+    0,
+    0,
+    13,  # sendAsset
+    b"\x30" * 32,
+    False,
+    10**16,
+    32,
+)
+# effectKind, effectTokenIndex, effectEvmAsset, timeoutAt, expectedBalance,
+# lastOrderL1Block: appended by the current build.
+_EFFECT_FIELDS = (1, 0, "0x" + "00" * 20, 1_790_609_702, 10**6, 1_164_341_800)
+
+
+def _pending_state_raw(*, pending: bool, settled: bool, legacy: bool) -> bytes:
+    l1 = (1_168_823_034, 1_790_931_001, True)
+    if legacy:
+        inner = encode(
+            [LEGACY_PENDING_STATE_TYPE],
+            [(_STATE_PREFIX, pending, settled, False, *l1)],
+        )
+    else:
+        inner = encode(
+            [PENDING_STATE_TYPE],
+            [(_STATE_PREFIX + _EFFECT_FIELDS, pending, settled, *l1)],
+        )
     return encode(["(bytes)"], [(inner,)])
 
 
 class TestUniversalRead:
-    def test_pending_state_reads_through_the_vault(self):
+    @pytest.mark.parametrize("legacy", [False, True])
+    def test_pending_state_reads_through_the_vault(self, legacy: bool):
         ctx = _ctx()
-        ctx.call.return_value = _pending_state_raw(pending=False, settled=True)
+        ctx.call.return_value = _pending_state_raw(
+            pending=False, settled=True, legacy=legacy
+        )
         reader = HyperCorePendingReader(VAULT, READER)
 
         state = reader.pending_state().call(ctx)
@@ -203,13 +223,29 @@ class TestUniversalRead:
             1_168_823_034,
             True,
         )
+        assert state.current_timestamp == 1_790_931_001
         assert state.payload_hash == b"\x30" * 32
 
-    def test_is_pending_and_balance_fuse_value_decode_their_payloads(self):
+    @pytest.mark.parametrize("legacy", [False, True])
+    def test_is_pending_is_the_pending_state_predicate(self, legacy: bool):
         ctx = _ctx()
-        vault = PlasmaVault(VAULT)
-        ctx.call.return_value = encode(["(bytes)"], [(encode(["bool"], [True]),)])
+        ctx.call.return_value = _pending_state_raw(
+            pending=True, settled=False, legacy=legacy
+        )
         assert HyperCorePendingReader(VAULT, READER).is_pending().call(ctx) is True
+        assert ctx.call.call_args.args[1][4:] == encode(
+            ["address", "bytes"], [READER, _selector("pendingState()")]
+        )
+
+    def test_unknown_payload_size_is_refused(self):
+        ctx = _ctx()
+        ctx.call.return_value = encode(["(bytes)"], [(b"\x00" * 32 * 20,)])
+        with pytest.raises(UnsupportedContractVersionError, match="640 bytes"):
+            HyperCorePendingReader(VAULT, READER).pending_state().call(ctx)
+
+    def test_balance_fuse_value_and_raw_read_decode_their_payloads(self):
+        ctx = _ctx()
+        vault = PlasmaVault(VAULT)
         ctx.call.return_value = encode(
             ["(bytes)"], [(encode(["uint256"], [8_245_000_000_000_000]),)]
         )
@@ -226,7 +262,9 @@ class TestUniversalRead:
     def test_reported_order_state_maps_the_enums(self):
         ctx = _ctx()
         state = (0, 0, 0, 2, 2, 2, 5, 1, b"\x00" * 32, True, 0, 1)
-        inner = encode([PENDING_STATE_TYPE], [(state, True, False, True, 0, 0, False)])
+        inner = encode(
+            [LEGACY_PENDING_STATE_TYPE], [(state, True, False, True, 0, 0, False)]
+        )
         ctx.call.return_value = encode(["(bytes)"], [(inner,)])
         decoded = HyperCorePendingReader(VAULT, READER).pending_state().call(ctx)
         assert decoded.action_class is HyperCoreActionClass.ORDER
@@ -258,7 +296,7 @@ def _universal_read(data: bytes) -> bytes:
     """`PlasmaVault.read` double: the pending reader or the balance fuse."""
     target, inner = decode(["address", "bytes"], data[4:])
     if Web3.to_checksum_address(target) == READER:
-        return _pending_state_raw(pending=False, settled=True)
+        return _pending_state_raw(pending=False, settled=True, legacy=False)
     assert Web3.to_checksum_address(target) == BALANCE_FUSE
     assert bytes(inner) == _selector("balanceOf()")
     return encode(["(bytes)"], [(encode(["uint256"], [8_245_000_000_000_000]),)])