wayfinder-paths 0.1.29__py3-none-any.whl → 0.1.31__py3-none-any.whl

wayfinder_paths/strategies/basis_trading_strategy/test_strategy.py

@@ -429,35 +429,34 @@ class TestBasisTradingStrategy:
             coin="ETH",
             spot_asset_id=10000,
             perp_asset_id=1,
-            spot_amount=1.0,
-            perp_amount=1.0,
+            spot_amount=0.03,
+            perp_amount=0.03,
             entry_price=2000.0,
             leverage=2,
             entry_timestamp=1700000000000,
             funding_collected=0.0,
         )
 
-        # Mock user state with perp position and idle capital
-        # totalNtlPos represents position notional value, set high to avoid rebalance trigger
-        # unused_usd = accountValue - totalNtlPos = 120 - 112 = 8
-        # threshold for rebalance = epsilon * 2 = max(5, 0.02 * 100) * 2 = 10
-        # 8 < 10 so no rebalance
-        # total_idle = withdrawable (12) + spot_usdc (8) = 20 > min_deploy (5) so will scale up
-        # order_usd = 20 * (2/3) = 13.33 > MIN_NOTIONAL_USD (10)
+        # Make sure there's deployable idle USDC without relying on marginSummary.withdrawable.
+        # With 2x leverage and ~0.03 ETH:
+        # - spot value ≈ 0.03 * 2000 = 60
+        # - perp contrib ≈ (2000*(1+1/2) - 2000) * 0.03 = 30
+        # - bankroll ≈ 30 + 60 + 20 = 110
+        # - allocated ≈ 30 + 60 = 90
+        # - unused ≈ 20 (deployable USDC) -> scale up
         mock_hyperliquid_adapter.get_user_state = AsyncMock(
             return_value=(
                 True,
                 {
                     "marginSummary": {
-                        "accountValue": "120",
+                        "accountValue": "30",
                         "withdrawable": "12",
-                        "totalNtlPos": "112",
                     },
                     "assetPositions": [
                         {
                             "position": {
                                 "coin": "ETH",
-                                "szi": "-1.0",
+                                "szi": "-0.03",
                                 "leverage": {"value": "2"},
                                 "liquidationPx": "2500",
                                 "entryPx": "2000",
@@ -467,14 +466,14 @@ class TestBasisTradingStrategy:
                 },
             )
         )
-        # Include ETH spot balance for leg balance check, plus USDC for idle capital
+        # Include ETH spot balance for leg balance check, plus USDC to deploy.
         mock_hyperliquid_adapter.get_spot_user_state = AsyncMock(
             return_value=(
                 True,
                 {
                     "balances": [
-                        {"coin": "ETH", "total": "1.0"},
-                        {"coin": "USDC", "total": "8"},
+                        {"coin": "ETH", "total": "0.03"},
+                        {"coin": "USDC", "total": "20"},
                     ]
                 },
             )
@@ -516,6 +515,117 @@ class TestBasisTradingStrategy:
             assert mock_filler.fill_pair_units.called
             assert success
 
+    @pytest.mark.asyncio
+    async def test_update_does_not_scale_on_perp_pnl_margin_release(
+        self, strategy, mock_hyperliquid_adapter
+    ):
+        """A favorable perp move can increase withdrawable margin; it should not trigger scale-up."""
+        strategy.deposit_amount = 100.0
+        strategy.current_position = BasisPosition(
+            coin="ETH",
+            spot_asset_id=10000,
+            perp_asset_id=1,
+            spot_amount=0.03,
+            perp_amount=0.03,
+            entry_price=2000.0,
+            leverage=2,
+            entry_timestamp=1700000000000,
+            funding_collected=0.0,
+        )
+
+        # Price down benefits the short perp; withdrawable may rise, but unused cash is ~0.
+        mock_hyperliquid_adapter.get_all_mid_prices = AsyncMock(
+            return_value=(True, {"ETH": 1800.0, "BTC": 50000.0})
+        )
+        mock_hyperliquid_adapter.get_user_state = AsyncMock(
+            return_value=(
+                True,
+                {
+                    "marginSummary": {
+                        "accountValue": "36",
+                        "withdrawable": "12",
+                    },
+                    "assetPositions": [
+                        {
+                            "position": {
+                                "coin": "ETH",
+                                "szi": "-0.03",
+                                "leverage": {"value": "2"},
+                                "liquidationPx": "2500",
+                                "entryPx": "2000",
+                            }
+                        }
+                    ],
+                },
+            )
+        )
+        mock_hyperliquid_adapter.get_spot_user_state = AsyncMock(
+            return_value=(True, {"balances": [{"coin": "ETH", "total": "0.03"}]})
+        )
+
+        strategy._scale_up_position = AsyncMock(return_value=(True, "scaled"))
+
+        success, _ = await strategy.update()
+        assert success
+        strategy._scale_up_position.assert_not_awaited()
+
+    @pytest.mark.asyncio
+    async def test_update_includes_rotation_cooldown_hint(
+        self, strategy, mock_hyperliquid_adapter
+    ):
+        strategy.deposit_amount = 100.0
+        strategy.current_position = BasisPosition(
+            coin="ETH",
+            spot_asset_id=10000,
+            perp_asset_id=1,
+            spot_amount=0.03,
+            perp_amount=0.03,
+            entry_price=2000.0,
+            leverage=2,
+            entry_timestamp=1700000000000,
+            funding_collected=0.0,
+        )
+
+        mock_hyperliquid_adapter.get_user_state = AsyncMock(
+            return_value=(
+                True,
+                {
+                    "marginSummary": {
+                        "accountValue": "0",
+                        "withdrawable": "0",
+                    },
+                    "assetPositions": [
+                        {
+                            "position": {
+                                "coin": "ETH",
+                                "szi": "-0.03",
+                                "leverage": {"value": "2"},
+                                "liquidationPx": "2500",
+                                "entryPx": "2000",
+                            }
+                        }
+                    ],
+                },
+            )
+        )
+        mock_hyperliquid_adapter.get_spot_user_state = AsyncMock(
+            return_value=(True, {"balances": [{"coin": "ETH", "total": "0.03"}]})
+        )
+
+        strategy._needs_new_position = AsyncMock(
+            return_value=(False, "Position healthy")
+        )
+        strategy._verify_leg_balance = AsyncMock(return_value=(True, "ok"))
+        strategy._unused_usd_now = AsyncMock(return_value=(0.0, 100.0))
+        strategy._ensure_stop_loss_valid = AsyncMock(
+            return_value=(True, "Stop-loss ok")
+        )
+        strategy._rotation_cooldown_hint = AsyncMock(return_value="3d 4h remaining")
+
+        success, msg = await strategy.update()
+        assert success
+        assert "Rotation: 3d 4h remaining" in msg
+
     @pytest.mark.asyncio
     async def test_ensure_builder_fee_approved_already_approved(
         self, mock_hyperliquid_adapter, ledger_adapter

wayfinder_paths/strategies/boros_hype_strategy/boros_ops_mixin.py

@@ -11,22 +11,18 @@ from datetime import datetime
 from typing import Any
 
 from loguru import logger
-from web3 import AsyncWeb3
 
 from wayfinder_paths.core.utils.transaction import encode_call, send_transaction
-from wayfinder_paths.core.utils.web3 import web3_from_chain_id
 
 from .constants import (
     BOROS_HYPE_MARKET_ID,
     BOROS_HYPE_TOKEN_ID,
     BOROS_MIN_DEPOSIT_HYPE,
     HYPE_NATIVE,
-    HYPE_OFT_ABI,
     HYPE_OFT_ADDRESS,
     HYPEREVM_CHAIN_ID,
     KHYPE_LST,
     LOOPED_HYPE,
-    LZ_EID_ARBITRUM,
     MIN_HYPE_GAS,
     USDC_ARB,
     USDT_ARB,
@@ -37,11 +33,6 @@ from .constants import (
 from .types import Inventory
 
 
-def _pad_address_bytes32(address: str) -> bytes:
-    checksum = AsyncWeb3.to_checksum_address(address)
-    return bytes.fromhex(checksum[2:]).rjust(32, b"\x00")
-
-
 class BorosHypeBorosOpsMixin:
     async def _fund_boros(
         self, params: dict[str, Any], inventory: Inventory
@@ -267,84 +258,21 @@ class BorosHypeBorosOpsMixin:
         bridge_amount_wei = min(target_wei, max_value_wei)
         if bridge_amount_wei <= 0:
             return True, "Boros funding: nothing to bridge"
-
-        to_bytes32 = _pad_address_bytes32(wallet_address)
-
-        async with web3_from_chain_id(HYPEREVM_CHAIN_ID) as w3:
-            contract = w3.eth.contract(
-                address=w3.to_checksum_address(HYPE_OFT_ADDRESS),
-                abi=HYPE_OFT_ABI,
-            )
-
-            conversion_rate = int(
-                await contract.functions.decimalConversionRate().call()
-            )  # OFT sharedDecimals rounding
-            if conversion_rate > 0:
-                bridge_amount_wei = (
-                    bridge_amount_wei // conversion_rate
-                ) * conversion_rate
-            if bridge_amount_wei <= 0:
-                return True, "Boros funding: amount too small after OFT rounding"
-
-            # Quote fee, then clamp amount to fit balance (amount + fee) while
-            # still leaving MIN_HYPE_GAS behind for future gas.
-            send_params = (
-                int(LZ_EID_ARBITRUM),
-                to_bytes32,
-                int(bridge_amount_wei),
-                0,
-                b"",
-                b"",
-                b"",
-            )
-            fee = await contract.functions.quoteSend(send_params, False).call()
-            native_fee = int(fee[0])
-            lz_token_fee = int(fee[1])
-
-            max_send_amount_wei = max(0, max_value_wei - native_fee)
-            if conversion_rate > 0:
-                max_send_amount_wei = (
-                    max_send_amount_wei // conversion_rate
-                ) * conversion_rate
-            if bridge_amount_wei > max_send_amount_wei:
-                bridge_amount_wei = max_send_amount_wei
-                if bridge_amount_wei <= 0:
-                    return False, "Insufficient HyperEVM HYPE to cover OFT bridge fee"
-
-                send_params = (
-                    int(LZ_EID_ARBITRUM),
-                    to_bytes32,
-                    int(bridge_amount_wei),
-                    0,
-                    b"",
-                    b"",
-                    b"",
-                )
-                fee = await contract.functions.quoteSend(send_params, False).call()
-                native_fee = int(fee[0])
-                lz_token_fee = int(fee[1])
-
-            total_value_wei = int(bridge_amount_wei) + int(native_fee)
-            if total_value_wei > max_value_wei:
-                return False, "Insufficient HyperEVM HYPE to bridge after fee quote"
-
-        tx = await encode_call(
-            target=HYPE_OFT_ADDRESS,
-            abi=HYPE_OFT_ABI,
-            fn_name="send",
-            args=[
-                send_params,
-                (int(native_fee), int(lz_token_fee)),
-                AsyncWeb3.to_checksum_address(wallet_address),
-            ],
-            from_address=wallet_address,
-            chain_id=HYPEREVM_CHAIN_ID,
-            value=total_value_wei,
+        (
+            ok_bridge,
+            bridge_res,
+        ) = await self.boros_adapter.bridge_hype_oft_hyperevm_to_arbitrum(
+            amount_wei=int(bridge_amount_wei),
+            max_value_wei=int(max_value_wei),
+            to_address=str(wallet_address),
+            from_address=str(wallet_address),
         )
+        if not ok_bridge:
+            return False, f"OFT bridge failed: {bridge_res}"
 
-        tx_hash = await send_transaction(tx, self._sign_callback, wait_for_receipt=True)
-
-        bridged_hype = float(bridge_amount_wei) / 1e18
+        tx_hash = str(bridge_res.get("tx_hash") or "")
+        bridged_wei = int(bridge_res.get("amount_wei") or 0)
+        bridged_hype = float(bridged_wei) / 1e18
         bridged_usd = bridged_hype * hype_price
 
         # Track in-flight amount so planner doesn't double-fund while the bridge settles.
@@ -360,7 +288,7 @@ class BorosHypeBorosOpsMixin:
 
         return True, (
             f"Bridging {bridged_hype:.6f} HYPE (≈${bridged_usd:.2f}) HyperEVM→Arbitrum via OFT; "
-            f"tx={tx_hash} (LayerZero: https://layerzeroscan.com/tx/{tx_hash}). "
+            f"tx={tx_hash} (LayerZero: {bridge_res.get('layerzeroscan')}). "
             "Once bridged HYPE lands on Arbitrum, the next tick will deposit it to Boros."
         )
 
@@ -431,41 +359,15 @@ class BorosHypeBorosOpsMixin:
                 f"({depositable_hype:.6f} HYPE)",
             )
 
-        # 0) Move any isolated collateral to cross margin (cleanup).
-        # Boros markets expire, so we need to get the actual market ID from isolated positions.
+        # 0) Cleanup: sweep any isolated collateral back to cross margin.
         try:
-            ok_bal, balances = await self.boros_adapter.get_account_balances(
+            ok_sweep, sweep_res = await self.boros_adapter.sweep_isolated_to_cross(
                 token_id=int(token_id)
             )
-            if ok_bal and isinstance(balances, dict):
-                isolated_positions = balances.get("isolated_positions", [])
-                logger.debug(
-                    f"Boros position check: isolated={balances.get('isolated', 0):.6f}, "
-                    f"cross={balances.get('cross', 0):.6f}, "
-                    f"total={balances.get('total', 0):.6f}, "
-                    f"isolated_positions={isolated_positions}"
-                )
-                for iso_pos in isolated_positions:
-                    iso_market_id = iso_pos.get("market_id")
-                    iso_balance = float(iso_pos.get("balance", 0) or 0.0)
-                    if iso_market_id and iso_balance > 0.001:
-                        iso_wei = int(iso_balance * 1e18)  # Boros cash units
-                        logger.info(
-                            f"Moving {iso_balance:.6f} collateral from isolated market {iso_market_id} to cross"
-                        )
-                        ok_xfer, res_xfer = await self.boros_adapter.cash_transfer(
-                            market_id=int(iso_market_id),
-                            amount_wei=iso_wei,
-                            is_deposit=False,  # isolated -> cross
-                        )
-                        if ok_xfer:
-                            await asyncio.sleep(2)
-                        else:
-                            logger.warning(
-                                f"Failed Boros isolated->cross transfer for market {iso_market_id}: {res_xfer}"
-                            )
+            if not ok_sweep:
+                logger.warning(f"Failed Boros isolated->cross sweep: {sweep_res}")
         except Exception as exc:  # noqa: BLE001
-            logger.warning(f"Failed Boros isolated->cross transfer: {exc}")
+            logger.warning(f"Failed Boros isolated->cross sweep: {exc}")
 
         # 1) Best-effort: if any OFT HYPE is sitting idle on Arbitrum, deposit it to cross margin.
         if inventory.hype_oft_arb_balance > 0.0:
@@ -491,104 +393,58 @@ class BorosHypeBorosOpsMixin:
             except Exception as exc:  # noqa: BLE001
                 logger.warning(f"Failed to deposit OFT HYPE to Boros: {exc}")
 
-        # Deposits can land as isolated cash for the given market_id; ensure we
-        # sweep isolated -> cross again before attempting to trade.
-        try:
-            ok_bal, balances = await self.boros_adapter.get_account_balances(
-                token_id=int(token_id)
-            )
-            if ok_bal and isinstance(balances, dict):
-                isolated_positions = balances.get("isolated_positions", [])
-                for iso_pos in isolated_positions:
-                    iso_market_id = iso_pos.get("market_id")
-                    iso_balance = float(iso_pos.get("balance", 0) or 0.0)
-                    if iso_market_id and iso_balance > 0.001:
-                        iso_wei = int(iso_balance * 1e18)  # Boros cash units
-                        logger.info(
-                            f"Moving {iso_balance:.6f} collateral from isolated market {iso_market_id} to cross"
-                        )
-                        ok_xfer, res_xfer = await self.boros_adapter.cash_transfer(
-                            market_id=int(iso_market_id),
-                            amount_wei=iso_wei,
-                            is_deposit=False,  # isolated -> cross
-                        )
-                        if ok_xfer:
-                            await asyncio.sleep(2)
-                        else:
-                            logger.warning(
-                                f"Failed Boros isolated->cross transfer for market {iso_market_id}: {res_xfer}"
-                            )
-        except Exception as exc:  # noqa: BLE001
-            logger.warning(
-                f"Failed Boros isolated->cross transfer after deposit: {exc}"
-            )
-
         # 2) Rollover: close positions in other markets (best effort).
         try:
-            for mid in inventory.boros_position_market_ids or []:
-                try:
-                    mid_int = int(mid)
-                except (TypeError, ValueError):
-                    continue
-                if mid_int <= 0 or mid_int == int(market_id):
-                    continue
-                try:
-                    await self.boros_adapter.close_positions_market(
-                        mid_int, token_id=int(token_id)
-                    )
-                    await asyncio.sleep(2)
-                except Exception as exc:  # noqa: BLE001
-                    logger.warning(f"Failed to close Boros market {mid_int}: {exc}")
+            ok_roll, roll_res = await self.boros_adapter.close_positions_except(
+                keep_market_id=int(market_id),
+                token_id=int(token_id),
+                market_ids=inventory.boros_position_market_ids or [],
+                best_effort=True,
+            )
+            if not ok_roll:
+                logger.warning(f"Failed Boros rollover close: {roll_res}")
         except Exception as exc:  # noqa: BLE001
             logger.warning(f"Failed Boros rollover close: {exc}")
 
-        success, positions = await self.boros_adapter.get_active_positions(
-            market_id=int(market_id)
+        yu_to_usd = (
+            float(inventory.hype_price_usd or 0.0)
+            if int(token_id) == BOROS_HYPE_TOKEN_ID
+            else 1.0
         )
-        if not success:
-            return False, "Failed to get Boros positions"
-
-        if positions:
-            pos = positions[0]
-            current_size_yu = abs(float(pos.get("size", 0) or 0.0))
-        else:
-            current_size_yu = 0.0
-
-        diff_yu = float(target_size_yu) - float(current_size_yu)
-        diff_usd_equiv = abs(diff_yu) * float(inventory.hype_price_usd or 0.0)
-        if diff_usd_equiv < self._planner_config.boros_resize_min_excess_usd:
-            return True, f"Boros position already at target ({current_size_yu:.4f} YU)"
-
-        size_yu_wei = int(abs(diff_yu) * 1e18)  # Boros YU wei
-
-        if diff_yu > 0:
-            # Open/increase SHORT side (receive fixed)
-            ok_open, open_res = await self.boros_adapter.place_rate_order(
-                market_id=int(market_id),
-                token_id=int(token_id),
-                size_yu_wei=size_yu_wei,
-                side="short",
-                tif="IOC",
+        ok_set, set_res = await self.boros_adapter.ensure_position_size_yu(
+            market_id=int(market_id),
+            token_id=int(token_id),
+            target_size_yu=float(target_size_yu),
+            tif="IOC",
+            min_resize_excess_usd=float(
+                self._planner_config.boros_resize_min_excess_usd
+            ),
+            yu_to_usd=float(yu_to_usd),
+        )
+        if not ok_set:
+            return False, f"Failed to ensure Boros position: {set_res}"
+
+        action = str(set_res.get("action") or "unknown")
+        diff_yu = float(set_res.get("diff_yu") or 0.0)
+        if action == "no_op":
+            return (
+                True,
+                f"Boros position already at target ({set_res.get('current_size_yu', 0.0):.4f} YU)",
             )
-            if not ok_open:
-                return False, f"Failed to open Boros position: {open_res}"
+        if action == "increase_short":
             return (
                 True,
                 f"Boros position increased by {diff_yu:.4f} YU on market {market_id}",
             )
-
-        # Close/decrease position
-        ok_close, close_res = await self.boros_adapter.close_positions_market(
-            market_id=int(market_id),
-            token_id=int(token_id),
-            size_yu_wei=size_yu_wei,
-        )
-        if not ok_close:
-            return False, f"Failed to close Boros position: {close_res}"
+        if action == "decrease":
+            return (
+                True,
+                f"Boros position decreased by {abs(diff_yu):.4f} YU on market {market_id}",
+            )
 
         return (
             True,
-            f"Boros position decreased by {abs(diff_yu):.4f} YU on market {market_id}",
+            f"Boros position adjusted ({action}) on market {market_id}: Δ={diff_yu:.4f} YU",
         )
 
     async def _complete_pending_withdrawal(

wayfinder_paths/strategies/boros_hype_strategy/constants.py

@@ -109,158 +109,7 @@ BOROS_ENABLE_MIN_TOTAL_USD = 80.0  # Skip Boros if capital below this
 
 # LayerZero OFT bridge (HyperEVM native HYPE -> Arbitrum OFT HYPE)
 # HYPE_OFT_ADDRESS imported from contracts.py
-LZ_EID_ARBITRUM = 30110
-
-# Minimal IOFT ABI for quoting + sending.
-HYPE_OFT_ABI = [
-    {
-        "inputs": [
-            {
-                "components": [
-                    {"internalType": "uint32", "name": "dstEid", "type": "uint32"},
-                    {"internalType": "bytes32", "name": "to", "type": "bytes32"},
-                    {"internalType": "uint256", "name": "amountLD", "type": "uint256"},
-                    {
-                        "internalType": "uint256",
-                        "name": "minAmountLD",
-                        "type": "uint256",
-                    },
-                    {
-                        "internalType": "bytes",
-                        "name": "extraOptions",
-                        "type": "bytes",
-                    },
-                    {"internalType": "bytes", "name": "composeMsg", "type": "bytes"},
-                    {"internalType": "bytes", "name": "oftCmd", "type": "bytes"},
-                ],
-                "internalType": "struct SendParam",
-                "name": "_sendParam",
-                "type": "tuple",
-            },
-            {"internalType": "bool", "name": "_payInLzToken", "type": "bool"},
-        ],
-        "name": "quoteSend",
-        "outputs": [
-            {
-                "components": [
-                    {"internalType": "uint256", "name": "nativeFee", "type": "uint256"},
-                    {
-                        "internalType": "uint256",
-                        "name": "lzTokenFee",
-                        "type": "uint256",
-                    },
-                ],
-                "internalType": "struct MessagingFee",
-                "name": "",
-                "type": "tuple",
-            }
-        ],
-        "stateMutability": "view",
-        "type": "function",
-    },
-    {
-        "inputs": [
-            {
-                "components": [
-                    {"internalType": "uint32", "name": "dstEid", "type": "uint32"},
-                    {"internalType": "bytes32", "name": "to", "type": "bytes32"},
-                    {"internalType": "uint256", "name": "amountLD", "type": "uint256"},
-                    {
-                        "internalType": "uint256",
-                        "name": "minAmountLD",
-                        "type": "uint256",
-                    },
-                    {
-                        "internalType": "bytes",
-                        "name": "extraOptions",
-                        "type": "bytes",
-                    },
-                    {"internalType": "bytes", "name": "composeMsg", "type": "bytes"},
-                    {"internalType": "bytes", "name": "oftCmd", "type": "bytes"},
-                ],
-                "internalType": "struct SendParam",
-                "name": "_sendParam",
-                "type": "tuple",
-            },
-            {
-                "components": [
-                    {"internalType": "uint256", "name": "nativeFee", "type": "uint256"},
-                    {
-                        "internalType": "uint256",
-                        "name": "lzTokenFee",
-                        "type": "uint256",
-                    },
-                ],
-                "internalType": "struct MessagingFee",
-                "name": "_fee",
-                "type": "tuple",
-            },
-            {"internalType": "address", "name": "_refundAddress", "type": "address"},
-        ],
-        "name": "send",
-        "outputs": [
-            {
-                "components": [
-                    {"internalType": "bytes32", "name": "guid", "type": "bytes32"},
-                    {"internalType": "uint64", "name": "nonce", "type": "uint64"},
-                    {
-                        "components": [
-                            {
-                                "internalType": "uint256",
-                                "name": "nativeFee",
-                                "type": "uint256",
-                            },
-                            {
-                                "internalType": "uint256",
-                                "name": "lzTokenFee",
-                                "type": "uint256",
-                            },
-                        ],
-                        "internalType": "struct MessagingFee",
-                        "name": "fee",
-                        "type": "tuple",
-                    },
-                ],
-                "internalType": "struct MessagingReceipt",
-                "name": "",
-                "type": "tuple",
-            },
-            {
-                "components": [
-                    {
-                        "internalType": "uint256",
-                        "name": "amountSentLD",
-                        "type": "uint256",
-                    },
-                    {
-                        "internalType": "uint256",
-                        "name": "amountReceivedLD",
-                        "type": "uint256",
-                    },
-                ],
-                "internalType": "struct OFTReceipt",
-                "name": "",
-                "type": "tuple",
-            },
-        ],
-        "stateMutability": "payable",
-        "type": "function",
-    },
-    {
-        "inputs": [],
-        "name": "sharedDecimals",
-        "outputs": [{"internalType": "uint8", "name": "", "type": "uint8"}],
-        "stateMutability": "view",
-        "type": "function",
-    },
-    {
-        "inputs": [],
-        "name": "decimalConversionRate",
-        "outputs": [{"internalType": "uint256", "name": "", "type": "uint256"}],
-        "stateMutability": "view",
-        "type": "function",
-    },
-]
+# ABI lives in `wayfinder_paths/core/constants/hype_oft_abi.py`.
 
 # ─────────────────────────────────────────────────────────────────────────────
 # GAS CONFIGURATION