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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: ipor-fusion
-Version: 4.1.0.dev35
+Version: 4.1.0.dev40
 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.dev35 → ipor_fusion-4.1.0.dev40}/examples/hypercore_vault_official_deployment_hyperevm.py

@@ -95,12 +95,14 @@ from ipor_fusion import (
     Web3Context,
     decode_substrate,
     erc20_balance_slot,
+    format_amount,
     is_simulate_v1_supported,
     parse_checksum_address,
     parse_fuse_address,
 )
 from ipor_fusion.hypercore import (
     HYPERCORE_PENDING_READERS,
+    ORDER_DECIMALS,
     SPOT_DEX,
     USDC_SYSTEM_ADDRESS,
     USDC_TOKEN_INDEX,
@@ -119,6 +121,7 @@ from ipor_fusion.hypercore import (
     TimeInForce,
     decode_hypercore_event,
     hip3_action_asset,
+    perp_px_decimals,
     precompile_index_of,
 )
 from ipor_fusion.market_ids import IporFusionMarkets
@@ -224,9 +227,10 @@ BRIDGE_AMOUNT = Amount(15_000_000)  # 15 USDC EVM -> Core
 # whose default is that same 1 USDC in Core wei.
 ACTIVATION_FEE_WEI = 100_000_000
 TO_DEX_WEI = 1_000_000_000  # 10 USDC spot -> xyz dex
-ORDER_SIZE = 5_000_000  # 0.05 xyz:NVDA (a multiple of the 10**(8 - 3) lot)
-LIMIT_BUY_PX = 230 * 10**8  # pays at most 230 USD
-LIMIT_SELL_PX = 220 * 10**8  # sells at no less than 220 USD
+# 0.05 xyz:NVDA, a multiple of its 10**(ORDER_DECIMALS - 3) lot
+ORDER_SIZE = 5 * 10 ** (ORDER_DECIMALS - 2)
+LIMIT_BUY_PX = 230 * 10**ORDER_DECIMALS  # pays at most 230 USD
+LIMIT_SELL_PX = 220 * 10**ORDER_DECIMALS  # sells at no less than 220 USD
 # Core -> EVM: a spot -> spot sendAsset to the USDC system address. The amount
 # must be a multiple of 100 Core wei (representable in 6 EVM decimals); Core
 # takes its transfer fee from what stays on spot.
@@ -374,7 +378,7 @@ def core_ledger() -> tuple[CoreAnswers, ...]:
     bridged = BRIDGE_AMOUNT * CORE_WEI_PER_EVM_UNIT - ACTIVATION_FEE_WEI
     mark = 225_000
     on_dex = TO_DEX_WEI // 100  # Core wei -> USD6
-    filled = ORDER_SIZE // 10 ** (8 - XYZ_NVDA_SZ_DECIMALS)
+    filled = ORDER_SIZE // 10 ** (ORDER_DECIMALS - XYZ_NVDA_SZ_DECIMALS)
     return (
         CoreAnswers(False, 0, 0, 0, mark),  # before the bridge: no Core account
         CoreAnswers(True, bridged, 0, 0, mark),  # the bridge landed
@@ -481,7 +485,7 @@ def check_core_metadata(
         f"{XYZ_NVDA_COIN} szDecimals is {nvda_info.sz_decimals}",
     )
     _check(
-        ORDER_SIZE % 10 ** (8 - nvda_info.sz_decimals) == 0,
+        ORDER_SIZE % 10 ** (ORDER_DECIMALS - nvda_info.sz_decimals) == 0,
         "the order size is not a whole number of lots",
     )
 
@@ -512,7 +516,7 @@ def read_core_metadata_at_head(web3: Web3) -> None:
         wallet_token,
         nvda_info.coin,
         nvda_info.sz_decimals,
-        mark / 10 ** (6 - nvda_info.sz_decimals),
+        format_amount(Amount(mark), perp_px_decimals(nvda_info.sz_decimals)),
     )
 
 

{ipor_fusion-4.1.0.dev35 → ipor_fusion-4.1.0.dev40}/pyproject.toml

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

{ipor_fusion-4.1.0.dev35 → ipor_fusion-4.1.0.dev40}/src/ipor_fusion/fuses/hypercore.py

@@ -17,7 +17,7 @@ native perp dex is 0. A HIP-3 builder-deployed market is addressed by its
 action asset ``100_000 + dex * 10_000 + index_in_dex`` in orders, cancels and
 the PerpMarket substrate; the read precompiles take ``dex * 10_000 +
 index_in_dex`` instead (:func:`precompile_index_of`). Amounts are Core integers:
-``limit_px`` and ``sz`` carry 8 implied decimals, ``usd6`` 6, and
+``limit_px`` and ``sz`` carry :data:`ORDER_DECIMALS` implied decimals, ``usd6`` 6, and
 ``amount_wei`` is Core wei (8 decimals for USDC).
 
 ABI (one struct argument per method)::
@@ -64,6 +64,8 @@ from ipor_fusion.types import (
 SPOT_DEX = 0xFFFFFFFF
 #: ``HyperCoreLib.NATIVE_PERP_DEX``: Hyperliquid's own perp dex.
 NATIVE_PERP_DEX = 0
+#: Decimals of ``limit_px`` and ``sz`` in :meth:`HyperCoreOrderFuse.enter`.
+ORDER_DECIMALS = 8
 #: Core token index of USDC.
 USDC_TOKEN_INDEX = HyperCoreTokenIndex(0)
 #: Core -> EVM route for token 0: a spot -> spot ``sendAsset`` to this address
@@ -297,7 +299,8 @@ class HyperCoreOrderFuse(Fuse):
         cloid: HyperCoreClientOrderId,
         reduce_only: bool = False,
     ) -> FuseAction:
-        """Place ``sz`` (8 decimals) of ``asset`` at ``limit_px`` (8 decimals).
+        """Place ``sz`` of ``asset`` at ``limit_px``, both with
+        :data:`ORDER_DECIMALS` decimals.
         The fuse enforces the market's notional cap and lot size and, for
         HIP-3 markets, that this is the vault's only PerpMarket grant."""
         _validate_uint(asset, 32, "asset")

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

@@ -8,6 +8,7 @@ with no backward compatibility, which is why they live here rather than in
 """
 
 from ipor_fusion.fuses.hypercore import (
+    ORDER_DECIMALS,
     RESERVED_HYPERCORE_CONFIG_KEYS,
     SPOT_DEX,
     USDC_SYSTEM_ADDRESS,
@@ -68,6 +69,8 @@ from ipor_fusion.fuses.hypercore_pre_hooks import (
 from ipor_fusion.readers.hypercore import (
     HYPERCORE_MARKET,
     HYPERCORE_PENDING_READERS,
+    PERP_MAX_DECIMALS,
+    USD6_DECIMALS,
     HyperCoreAccountMarginSummary,
     HyperCoreActionClass,
     HyperCoreEffectKind,
@@ -84,6 +87,7 @@ from ipor_fusion.readers.hypercore import (
     HyperCoreTokenInfo,
     HyperCoreVaultState,
     convert_to_wad_int,
+    perp_px_decimals,
     read_hypercore_nav,
     read_hypercore_vault_state,
 )
@@ -110,9 +114,12 @@ from ipor_fusion.types import (
 
 __all__ = [
     "MarginTableId",
+    "ORDER_DECIMALS",
+    "PERP_MAX_DECIMALS",
     "PayloadHash",
     "SPOT_DEX",
     "TransferDirection",
+    "USD6_DECIMALS",
     "USDC_SYSTEM_ADDRESS",
     "USDC_TOKEN_INDEX",
     "HYPERCORE_CAPITAL_FLOW_SELECTORS",
@@ -190,6 +197,7 @@ __all__ = [
     "is_hip3_asset",
     "is_native_perp_asset",
     "perp_dex_of",
+    "perp_px_decimals",
     "precompile_index_of",
     "read_hypercore_evm_exit_ceiling",
     "read_hypercore_nav",

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

@@ -81,6 +81,10 @@ HYPERCORE_PENDING_READERS: dict[ChainId, ChecksumAddress] = {
 WAD_DECIMALS = 18
 #: ``accountMarginSummary`` reports USD with 6 decimals.
 USD6_DECIMALS = 6
+#: The most decimals a perp price can carry: Hyperliquid's ``MAX_DECIMALS``,
+#: which is 6 for perps (8 for spot). A perp's price has
+#: ``PERP_MAX_DECIMALS - szDecimals`` decimals (:func:`perp_px_decimals`).
+PERP_MAX_DECIMALS = 6
 _INT256_MAX = (1 << 255) - 1
 
 
@@ -111,6 +115,16 @@ def _validate_uint(value: int, bits: int, name: str) -> None:
         raise ValueError(f"{name} must fit in uint{bits}, got {value}")
 
 
+def perp_px_decimals(sz_decimals: Decimals) -> Decimals:
+    """Decimals of a perp's :meth:`HyperCoreReader.mark_px` and
+    :meth:`HyperCoreReader.oracle_px`, from its ``szDecimals``."""
+    if not 0 <= sz_decimals <= PERP_MAX_DECIMALS:
+        raise ValueError(
+            f"sz_decimals must be in 0..{PERP_MAX_DECIMALS}, got {sz_decimals}"
+        )
+    return Decimals(PERP_MAX_DECIMALS - sz_decimals)
+
+
 @dataclass(frozen=True, slots=True)
 class HyperCoreSpotBalance:
     """``spotBalance`` precompile result, all in Core wei of the token."""
@@ -306,10 +320,12 @@ class HyperCoreReader:
         return self._read(WITHDRAWABLE_PRECOMPILE, ["address"], [user], ["uint64"])
 
     def oracle_px(self, read_index: int) -> Call[int]:
+        """A perp's oracle price, with :func:`perp_px_decimals` decimals."""
         _validate_uint(read_index, 32, "read_index")
         return self._read(ORACLE_PX_PRECOMPILE, ["uint32"], [read_index], ["uint64"])
 
     def mark_px(self, read_index: int) -> Call[int]:
+        """A perp's mark price, with :func:`perp_px_decimals` decimals."""
         _validate_uint(read_index, 32, "read_index")
         return self._read(MARK_PX_PRECOMPILE, ["uint32"], [read_index], ["uint64"])
 

{ipor_fusion-4.1.0.dev35 → ipor_fusion-4.1.0.dev40}/src/ipor_fusion/readers/oracle_mapping.py

@@ -236,15 +236,32 @@ def _resolve_middleware_fallback(
     node.source_type = TYPE_MIDDLEWARE_FALLBACK
     node.status = "resolved"
     if underlying_middleware is not None:
-        # Same asset, different oracle — must not be in `visited` yet; runaway
-        # manager→manager chains are bounded by max_depth instead.
-        dep = _resolve(
-            reader.delegate(underlying_middleware),
-            asset,
-            depth + 1,
-            visited,
-            max_depth,
-        )
+        # Same asset, different oracle: the asset key is not in `visited` yet,
+        # so the hop is keyed by (oracle, asset) — a manager chain that loops
+        # back ends as a cycle instead of running to max_depth.
+        hop = f"{underlying_middleware.lower()}/{asset.lower()}"
+        if hop in visited:
+            return _partial(
+                asset,
+                symbol,
+                decimals,
+                source,
+                TYPE_UNKNOWN,
+                "cycle_detected",
+                [label],
+                price,
+            )
+        visited.add(hop)
+        try:
+            dep = _resolve(
+                reader.delegate(underlying_middleware),
+                asset,
+                depth + 1,
+                visited,
+                max_depth,
+            )
+        finally:
+            visited.discard(hop)
         node.dependencies = [dep]
         # dep re-resolves the same asset, so drop its leading label from the path.
         node.path = [label, "middleware fallback", *dep.path[1:]]

{ipor_fusion-4.1.0.dev35 → ipor_fusion-4.1.0.dev40}/src/ipor_fusion/vault_data.py

@@ -312,7 +312,21 @@ def resolve_token_decimals(ctx: Web3Context, address: HexAddress) -> Decimals |
     return decimals
 
 
-def _block_timestamp(ctx: Web3Context, block: int) -> Timestamp:
+def _latest_head(ctx: Web3Context) -> tuple[int, Timestamp]:
+    """The latest block's number and timestamp from one read.
+
+    Reading the head number first and the block by number second can reach a
+    node behind a load balancer that has not seen that block yet.
+    """
+    head = ctx.web3.eth.get_block("latest")
+    return head["number"], head["timestamp"]
+
+
+def _block_timestamp(
+    ctx: Web3Context, block: int, known: Timestamp | None
+) -> Timestamp:
+    if known is not None:
+        return known
     return ctx.web3.eth.get_block(block)["timestamp"]
 
 
@@ -634,14 +648,18 @@ def fetch_vault_data(
     ensure_supported_chain(ctx.chain_id)
     if block is None:
         block = _pinned_default_block(ctx)
-    resolved_block = ctx.web3.eth.block_number if block is None else block
     is_latest = block is None
+    head_timestamp: Timestamp | None = None
+    if block is None:
+        resolved_block, head_timestamp = _latest_head(ctx)
+    else:
+        resolved_block = block
     ctx = ctx.at_block(resolved_block)
     plasma_vault = PlasmaVault(vault)
     with ThreadPoolExecutor() as pool:
         # Independent pipelines, each a short chain of batched reads; none of
         # them waits on a pool future, so they cannot starve the pool.
-        f_timestamp = pool.submit(_block_timestamp, ctx, resolved_block)
+        f_timestamp = pool.submit(_block_timestamp, ctx, resolved_block, head_timestamp)
         f_vault = pool.submit(_fetch_vault_reads, ctx, plasma_vault)
         f_fees = pool.submit(_fetch_fee_data, ctx, plasma_vault)
         f_withdraw = pool.submit(_fetch_withdraw_manager, ctx, plasma_vault)

{ipor_fusion-4.1.0.dev35 → ipor_fusion-4.1.0.dev40}/tests/test_cli_commands.py

@@ -443,7 +443,10 @@ class TestVaultInfo:
         mock_ctx.cache = NullCache()
         mock_ctx.web3.eth.block_number = 12345678
         mock_ctx.default_block = "latest"
-        mock_ctx.web3.eth.get_block.return_value = {"timestamp": 1700000000}
+        mock_ctx.web3.eth.get_block.return_value = {
+            "number": 12345678,
+            "timestamp": 1700000000,
+        }
         mock_ctx.chain_id = 1
         mock_ctx.at_block.return_value = mock_ctx
         mock_ctx_cls.from_url.return_value = mock_ctx
@@ -573,7 +576,10 @@ class TestVaultInfo:
         mock_ctx.cache = NullCache()
         mock_ctx.web3.eth.block_number = 12345678
         mock_ctx.default_block = "latest"
-        mock_ctx.web3.eth.get_block.return_value = {"timestamp": 1700000000}
+        mock_ctx.web3.eth.get_block.return_value = {
+            "number": 12345678,
+            "timestamp": 1700000000,
+        }
         mock_ctx.chain_id = 1
         mock_ctx.at_block.return_value = mock_ctx
         mock_ctx_cls.from_url.return_value = mock_ctx
@@ -654,7 +660,10 @@ class TestVaultInfo:
         mock_ctx.cache = NullCache()
         mock_ctx.web3.eth.block_number = 100
         mock_ctx.default_block = "latest"
-        mock_ctx.web3.eth.get_block.return_value = {"timestamp": 1700000000}
+        mock_ctx.web3.eth.get_block.return_value = {
+            "number": 100,
+            "timestamp": 1700000000,
+        }
         mock_ctx.chain_id = 1
         mock_ctx.at_block.return_value = mock_ctx
         mock_ctx_cls.from_url.return_value = mock_ctx
@@ -723,7 +732,10 @@ class TestVaultInfo:
         mock_ctx.cache = NullCache()
         mock_ctx.web3.eth.block_number = 100
         mock_ctx.default_block = "latest"
-        mock_ctx.web3.eth.get_block.return_value = {"timestamp": 1700000000}
+        mock_ctx.web3.eth.get_block.return_value = {
+            "number": 100,
+            "timestamp": 1700000000,
+        }
         mock_ctx.chain_id = 1
         mock_ctx.at_block.return_value = mock_ctx
         mock_ctx_cls.from_url.return_value = mock_ctx
@@ -804,7 +816,10 @@ class TestVaultInfo:
         mock_ctx.cache = NullCache()
         mock_ctx.web3.eth.block_number = 100
         mock_ctx.default_block = "latest"
-        mock_ctx.web3.eth.get_block.return_value = {"timestamp": 1700000000}
+        mock_ctx.web3.eth.get_block.return_value = {
+            "number": 100,
+            "timestamp": 1700000000,
+        }
         mock_ctx.web3.eth.get_transaction.return_value = {"blockNumber": 18500000}
         mock_ctx.chain_id = 1
         mock_ctx.at_block.return_value = mock_ctx
@@ -875,7 +890,10 @@ class TestVaultInfo:
         mock_ctx.cache = NullCache()
         mock_ctx.web3.eth.block_number = 100
         mock_ctx.default_block = "latest"
-        mock_ctx.web3.eth.get_block.return_value = {"timestamp": 1700000000}
+        mock_ctx.web3.eth.get_block.return_value = {
+            "number": 100,
+            "timestamp": 1700000000,
+        }
         mock_ctx.chain_id = 1
         mock_ctx.at_block.return_value = mock_ctx
         mock_ctx_cls.from_url.return_value = mock_ctx
@@ -986,7 +1004,10 @@ class TestVaultInfoJson:
         mock_ctx.chain_id = 1
         mock_ctx.web3.eth.block_number = 12345678
         mock_ctx.default_block = "latest"
-        mock_ctx.web3.eth.get_block.return_value = {"timestamp": 1700000000}
+        mock_ctx.web3.eth.get_block.return_value = {
+            "number": 12345678,
+            "timestamp": 1700000000,
+        }
         mock_ctx.chain_id = 1
         mock_ctx.at_block.return_value = mock_ctx
         mock_ctx_cls.from_url.return_value = mock_ctx
@@ -1165,7 +1186,10 @@ class TestVaultInfoJson:
         mock_ctx.cache = NullCache()
         mock_ctx.web3.eth.block_number = 100
         mock_ctx.default_block = "latest"
-        mock_ctx.web3.eth.get_block.return_value = {"timestamp": 1700000000}
+        mock_ctx.web3.eth.get_block.return_value = {
+            "number": 100,
+            "timestamp": 1700000000,
+        }
         mock_ctx.web3.eth.get_transaction.return_value = {"blockNumber": 18500000}
         mock_ctx.chain_id = 1
         mock_ctx.at_block.return_value = mock_ctx
@@ -1246,7 +1270,10 @@ class TestVaultInfoJson:
         mock_ctx.cache = NullCache()
         mock_ctx.web3.eth.block_number = 100
         mock_ctx.default_block = "latest"
-        mock_ctx.web3.eth.get_block.return_value = {"timestamp": 1700000000}
+        mock_ctx.web3.eth.get_block.return_value = {
+            "number": 100,
+            "timestamp": 1700000000,
+        }
         mock_ctx.chain_id = 1
         mock_ctx.at_block.return_value = mock_ctx
         mock_ctx_cls.from_url.return_value = mock_ctx

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

@@ -29,6 +29,7 @@ from ipor_fusion.hypercore import (
     HyperCoreSpotBalance,
     HyperCoreTokenInfo,
     convert_to_wad_int,
+    perp_px_decimals,
     read_hypercore_nav,
 )
 from ipor_fusion.readers.hypercore import (
@@ -335,6 +336,17 @@ def test_convert_to_wad_int_rounds_like_ipor_math(value, decimals, expected):
     assert convert_to_wad_int(value, decimals) == expected
 
 
+@pytest.mark.parametrize(("sz_decimals", "expected"), [(0, 6), (5, 1), (6, 0)])
+def test_perp_px_decimals(sz_decimals, expected):
+    assert perp_px_decimals(sz_decimals) == expected
+
+
+@pytest.mark.parametrize("sz_decimals", [-1, 7])
+def test_perp_px_decimals_rejects_out_of_range(sz_decimals):
+    with pytest.raises(ValueError, match="sz_decimals"):
+        perp_px_decimals(sz_decimals)
+
+
 def _universal_read(data: bytes) -> bytes:
     """`PlasmaVault.read` double: the pending reader or the balance fuse."""
     target, inner = decode(["address", "bytes"], data[4:])

{ipor_fusion-4.1.0.dev35 → ipor_fusion-4.1.0.dev40}/tests/test_oracle_mapping.py

@@ -636,6 +636,26 @@ class TestResolve:
             "chainlink_feed_registry": None,
         }
 
+    def test_manager_delegating_to_itself_ends_as_a_cycle(self):
+        r = FakeReader()
+        weth = addr(1)
+        mw = addr(0x51)
+        zero = Web3.to_checksum_address(om.ZERO_ADDRESS)
+        r.symbols[weth] = "WETH"
+        r.decimals[weth] = 18
+        r.sources[weth] = zero
+        r.prices[weth] = Price(asset=weth, amount=2_000 * 10**18, decimals=18)
+        r.underlying_mw = mw
+        r.delegated = r  # the manager names itself as its underlying middleware
+
+        node = om.resolve_asset(r, weth, max_depth=50)
+
+        # one hop back to the same manager, not 50 down to max_depth
+        (dep,) = node.dependencies
+        assert dep.reason == "cycle_detected"
+        assert not dep.dependencies
+        assert node.status == "partially_resolved"
+
     def test_zero_underlying_middleware_treated_as_absent(self):
         r = FakeReader()
         asset = addr(1)

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

@@ -516,10 +516,13 @@ _ALL_SNAPSHOT: dict[str, frozenset[str]] = {
             "HyperCoreTransferStatus",
             "HyperCoreVaultState",
             "MarginTableId",
+            "ORDER_DECIMALS",
+            "PERP_MAX_DECIMALS",
             "PayloadHash",
             "SPOT_DEX",
             "TimeInForce",
             "TransferDirection",
+            "USD6_DECIMALS",
             "USDC_SYSTEM_ADDRESS",
             "USDC_TOKEN_INDEX",
             "compare_hypercore_transfer",
@@ -532,6 +535,7 @@ _ALL_SNAPSHOT: dict[str, frozenset[str]] = {
             "is_hip3_asset",
             "is_native_perp_asset",
             "perp_dex_of",
+            "perp_px_decimals",
             "precompile_index_of",
             "read_hypercore_evm_exit_ceiling",
             "read_hypercore_nav",

{ipor_fusion-4.1.0.dev35 → ipor_fusion-4.1.0.dev40}/tests/test_vault_data_block.py

@@ -5,7 +5,7 @@ import pytest
 from ipor_fusion import Web3Context
 from ipor_fusion.cache import NullCache
 from ipor_fusion.types import ChainId
-from ipor_fusion.vault_data import _pinned_default_block
+from ipor_fusion.vault_data import _latest_head, _pinned_default_block
 
 
 def _ctx() -> tuple[Web3Context, MagicMock]:
@@ -32,3 +32,13 @@ def test_tag_or_hash_resolves_to_its_number_once(tag: str):
     ctx, web3 = _ctx()
     assert _pinned_default_block(ctx.at_block(tag)) == 4242  # type: ignore[arg-type]
     web3.eth.get_block.assert_called_once_with(tag)
+
+
+def test_latest_head_reads_number_and_timestamp_in_one_call():
+    # The head number and then get_block(number) can reach a node behind a
+    # load balancer that has not seen that block yet.
+    web3 = MagicMock()
+    web3.eth.get_block.return_value = {"number": 4242, "timestamp": 1_700_000_000}
+    ctx = Web3Context(web3, ChainId(1), cache=NullCache())
+    assert _latest_head(ctx) == (4242, 1_700_000_000)
+    web3.eth.get_block.assert_called_once_with("latest")