ipor-fusion 4.1.0.dev40__tar.gz → 4.1.0.dev44__tar.gz

{ipor_fusion-4.1.0.dev40 → ipor_fusion-4.1.0.dev44}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: ipor-fusion
-Version: 4.1.0.dev40
+Version: 4.1.0.dev44
 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.1.0.dev40 → ipor_fusion-4.1.0.dev44}/pyproject.toml

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

{ipor_fusion-4.1.0.dev40 → ipor_fusion-4.1.0.dev44}/src/ipor_fusion/core/address.py

@@ -2,13 +2,15 @@ def _validate_not_zero_address(value: str, name: str) -> None:
     """Reject an empty or zero address; ``name`` labels it in the error.
 
     Compares the parsed bytes rather than the text, so every spelling of the
-    zero address is caught -- ``0x``-prefixed or bare. Input that is not hex at
-    all falls through to the encoder, which reports the malformed address.
+    zero address is caught -- ``0x``- or ``0X``-prefixed, or bare. Input that
+    is not hex at all falls through to the encoder, which reports the
+    malformed address.
     """
     if not value:
         raise ValueError(f"{name} is required and must not be zero address")
+    digits = value[2:] if value[:2].lower() == "0x" else value
     try:
-        payload = bytes.fromhex(value.removeprefix("0x"))
+        payload = bytes.fromhex(digits)
     except ValueError:
         return
     if payload == bytes(20):

{ipor_fusion-4.1.0.dev40 → ipor_fusion-4.1.0.dev44}/src/ipor_fusion/hypercore/__init__.py

@@ -73,6 +73,7 @@ from ipor_fusion.readers.hypercore import (
     USD6_DECIMALS,
     HyperCoreAccountMarginSummary,
     HyperCoreActionClass,
+    HyperCoreBbo,
     HyperCoreEffectKind,
     HyperCoreNav,
     HyperCorePendingReader,
@@ -137,6 +138,7 @@ __all__ = [
     "HyperCoreActionSettledArgs",
     "HyperCoreActionSettledEvent",
     "HyperCoreAsset",
+    "HyperCoreBbo",
     "HyperCoreBuilderFeeFuse",
     "HyperCoreBuilderFeeFuseEnterArgs",
     "HyperCoreBuilderFeeFuseEnterEvent",

{ipor_fusion-4.1.0.dev40 → ipor_fusion-4.1.0.dev44}/src/ipor_fusion/readers/hypercore.py

@@ -99,6 +99,7 @@ ORACLE_PX_PRECOMPILE = _precompile(0x807)
 L1_BLOCK_NUMBER_PRECOMPILE = _precompile(0x809)
 PERP_ASSET_INFO_PRECOMPILE = _precompile(0x80A)
 TOKEN_INFO_PRECOMPILE = _precompile(0x80C)
+BBO_PRECOMPILE = _precompile(0x80E)
 ACCOUNT_MARGIN_SUMMARY_PRECOMPILE = _precompile(0x80F)
 CORE_USER_EXISTS_PRECOMPILE = _precompile(0x810)
 #: ``position2``: same layout as ``position`` (``0x800``), which reads indexes up
@@ -170,6 +171,15 @@ class HyperCorePerpAssetInfo:
     only_isolated: bool
 
 
+@dataclass(frozen=True, slots=True)
+class HyperCoreBbo:
+    """``bbo`` precompile result: the best bid and ask, ``None`` for an empty
+    side of the book, which the precompile answers as 0 (never a real price)."""
+
+    bid: int | None
+    ask: int | None
+
+
 @dataclass(frozen=True, slots=True)
 class HyperCorePosition:
     """``position`` precompile result; ``szi`` and ``isolated_raw_usd`` are
@@ -225,14 +235,19 @@ def _position(values: tuple[int, int, int, int, bool]) -> HyperCorePosition:
     return HyperCorePosition(*values)
 
 
+def _bbo(values: tuple[int, int]) -> HyperCoreBbo:
+    bid, ask = values
+    return HyperCoreBbo(bid=bid or None, ask=ask or None)
+
+
 class HyperCoreReader:
     """The HyperCore read precompiles as :class:`Call`s.
 
-    Mirrors ``HyperCoreLib``'s reads: a precompile takes its arguments as raw
-    ABI-encoded words (no selector) and answers one ABI-encoded value. The
-    perp reads take the *read index* of a market
+    Mirrors ``HyperCoreLib``'s reads, plus :meth:`bbo`: a precompile takes its
+    arguments as raw ABI-encoded words (no selector) and answers one
+    ABI-encoded value. The perp reads take the *read index* of a market
     (:func:`ipor_fusion.hypercore.precompile_index_of`: the action asset without the HIP-3
-    offset), never the action asset itself.
+    offset); only :meth:`bbo` takes the action asset itself.
     """
 
     def _read(
@@ -329,6 +344,15 @@ class HyperCoreReader:
         _validate_uint(read_index, 32, "read_index")
         return self._read(MARK_PX_PRECOMPILE, ["uint32"], [read_index], ["uint64"])
 
+    def bbo(self, asset: HyperCoreAsset) -> Call[HyperCoreBbo]:
+        """The best bid and ask of ``asset``, the action asset an order takes
+        (a HIP-3 read index answers another market's book). A perp's prices
+        have :func:`perp_px_decimals` decimals."""
+        _validate_uint(asset, 32, "asset")
+        return self._read(
+            BBO_PRECOMPILE, ["uint32"], [asset], ["uint64", "uint64"], _bbo
+        )
+
     def l1_block_number(self) -> Call[int]:
         return self._read(L1_BLOCK_NUMBER_PRECOMPILE, [], [], ["uint64"])
 

{ipor_fusion-4.1.0.dev40 → ipor_fusion-4.1.0.dev44}/tests/test_fuse_encoding.py

@@ -748,7 +748,7 @@ class TestUniversalTokenSwapperSubstrates:
         with pytest.raises(ValueError, match="20-byte"):
             UniversalTokenSwapperSubstrates.token("0x1234")  # type: ignore[arg-type]
 
-    @pytest.mark.parametrize("spelling", [ZERO_ADDRESS, "0" * 40])
+    @pytest.mark.parametrize("spelling", [ZERO_ADDRESS, "0X" + "0" * 40, "0" * 40])
     def test_zero_address_rejected(self, spelling):
         # Mirrors UniversalTokenSwapperSubstrateLibZeroAddress on-chain. The
         # error names the field, so a guard wired to the wrong one would show.
@@ -1214,9 +1214,9 @@ class TestSlippageParamsAllowZero:
 class TestFuseConstructorValidation:
     """Fuse constructor must reject zero and empty addresses."""
 
-    @pytest.mark.parametrize("spelling", [ZERO_ADDR, "0" * 40])
+    @pytest.mark.parametrize("spelling", [ZERO_ADDR, "0X" + "0" * 40, "0" * 40])
     def test_zero_address_rejected(self, spelling):
-        # Prefixed and un-prefixed name the same address; both must be caught.
+        # Every prefix spelling names the same address; all must be caught.
         with pytest.raises(ValueError, match="zero address"):
             AaveV3SupplyFuse(spelling)
 
@@ -2203,7 +2203,7 @@ class TestExternalStateSubstrates:
     @pytest.mark.parametrize(
         ("encoder", "field"), _ADDRESS_ENCODERS, ids=_ADDRESS_ENCODER_IDS
     )
-    @pytest.mark.parametrize("spelling", [ZERO_ADDRESS, "0" * 40])
+    @pytest.mark.parametrize("spelling", [ZERO_ADDRESS, "0X" + "0" * 40, "0" * 40])
     def test_zero_address_rejected(self, encoder, field, spelling):
         # Mirrors ExternalStateErrors.ExternalStateZeroAddress on-chain. The
         # bare spelling matters: config files and CSV exports drop the 0x, and

{ipor_fusion-4.1.0.dev40 → ipor_fusion-4.1.0.dev44}/tests/test_hypercore_readers.py

@@ -21,6 +21,7 @@ from ipor_fusion import (
 )
 from ipor_fusion.hypercore import (
     HyperCoreActionClass,
+    HyperCoreBbo,
     HyperCoreEffectKind,
     HyperCoreNav,
     HyperCorePendingReader,
@@ -152,11 +153,33 @@ class TestPrecompileCalls:
             self.reader.core_user_exists(VAULT).decode(encode(["bool"], [True])) is True
         )
 
+    def test_bbo_takes_the_action_asset(self):
+        call = self.reader.bbo(110_002)
+        # The literal, so a wrong BBO_PRECOMPILE fails.
+        assert call.to == Web3.to_checksum_address("0x" + "00" * 18 + "080e")
+        assert call.data == encode(["uint32"], [110_002])
+        bbo = call.decode(encode(["uint64", "uint64"], [213_750, 213_770]))
+        assert bbo == HyperCoreBbo(bid=213_750, ask=213_770)
+
+    def test_bbo_reads_an_empty_side_as_none(self):
+        empty_ask = self.reader.bbo(10_200).decode(
+            encode(["uint64", "uint64"], [18_700_000, 0])
+        )
+        assert empty_ask == HyperCoreBbo(bid=18_700_000, ask=None)
+        empty_bid = self.reader.bbo(10_200).decode(
+            encode(["uint64", "uint64"], [0, 18_800_000])
+        )
+        assert empty_bid == HyperCoreBbo(bid=None, ask=18_800_000)
+        empty = self.reader.bbo(10_220).decode(encode(["uint64", "uint64"], [0, 0]))
+        assert empty == HyperCoreBbo(bid=None, ask=None)
+
     def test_arguments_are_width_checked(self):
         with pytest.raises(ValueError, match="uint64"):
             self.reader.spot_balance(VAULT, 1 << 64)
         with pytest.raises(ValueError, match="uint32"):
             self.reader.perp_asset_info(1 << 32)
+        with pytest.raises(ValueError, match="uint32"):
+            self.reader.bbo(1 << 32)
 
 
 USDC = Web3.to_checksum_address("0xb88339cb7199b77e23db6e890353e22632ba630f")

{ipor_fusion-4.1.0.dev40 → ipor_fusion-4.1.0.dev44}/tests/test_public_api.py

@@ -467,6 +467,7 @@ _ALL_SNAPSHOT: dict[str, frozenset[str]] = {
             "HyperCoreActionSettledArgs",
             "HyperCoreActionSettledEvent",
             "HyperCoreAsset",
+            "HyperCoreBbo",
             "HyperCoreBuilderFeeFuse",
             "HyperCoreBuilderFeeFuseEnterArgs",
             "HyperCoreBuilderFeeFuseEnterEvent",