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

wayfinder_paths/adapters/boros_adapter/adapter.py

@@ -5,12 +5,11 @@ import time
 from collections.abc import Callable
 from typing import Any
 
-from eth_abi import encode
+from eth_abi import decode, encode
 from eth_utils import function_signature_to_4byte_selector, to_checksum_address
 from loguru import logger
 
 from wayfinder_paths.core.adapters.BaseAdapter import BaseAdapter
-from wayfinder_paths.core.constants.base import DEFAULT_TRANSACTION_TIMEOUT
 from wayfinder_paths.core.constants.contracts import BOROS_MARKET_HUB, BOROS_ROUTER
 from wayfinder_paths.core.utils.tokens import build_approve_transaction
 from wayfinder_paths.core.utils.transaction import send_transaction
@@ -115,6 +114,121 @@ class BorosAdapter(BaseAdapter):
         }
     ]
 
+    async def get_cash_fee_data(self, *, token_id: int) -> tuple[bool, dict[str, Any]]:
+        """Read MarketHub.getCashFeeData(tokenId) from chain.
+
+        This is useful for guarding Boros actions that require a minimum amount
+        of cross cash (e.g., MMInsufficientMinCash()).
+        """
+        try:
+            selector = function_signature_to_4byte_selector("getCashFeeData(uint16)")
+            params = encode(["uint16"], [int(token_id)])
+            data = "0x" + selector.hex() + params.hex()
+
+            async with web3_from_chain_id(self.chain_id) as web3:
+                raw: bytes = await web3.eth.call(
+                    {
+                        "to": to_checksum_address(BOROS_MARKET_HUB),
+                        "data": data,
+                    }
+                )
+
+            if len(raw) % 32 != 0:
+                return False, {"error": f"Unexpected getCashFeeData() size: {len(raw)}"}
+
+            n_words = len(raw) // 32
+            values = decode(["uint256"] * n_words, raw)
+            if len(values) < 4:
+                return False, {
+                    "error": f"Unexpected getCashFeeData() words: {len(values)}"
+                }
+
+            # Empirically (2026-02-01 on Arbitrum MarketHub), the return is 4 uint256s.
+            # We expose all 4, and provide float conversions for the commonly used ones.
+            scaling_factor_wei = int(values[0])
+            fee_rate_wei = int(values[1])
+            min_cash_cross_wei = int(values[2])
+            min_cash_isolated_wei = int(values[3])
+
+            return True, {
+                "token_id": int(token_id),
+                "scaling_factor_wei": scaling_factor_wei,
+                "fee_rate_wei": fee_rate_wei,
+                "min_cash_cross_wei": min_cash_cross_wei,
+                "min_cash_isolated_wei": min_cash_isolated_wei,
+                "fee_rate": fee_rate_wei / 1e18,
+                "min_cash_cross": min_cash_cross_wei / 1e18,
+                "min_cash_isolated": min_cash_isolated_wei / 1e18,
+            }
+        except Exception as exc:  # noqa: BLE001
+            return False, {"error": str(exc)}
+
+    async def sweep_isolated_to_cross(
+        self,
+        *,
+        token_id: int,
+        market_id: int | None = None,
+        token_decimals: int = 18,
+    ) -> tuple[bool, dict[str, Any]]:
+        """Sweep isolated cash -> cross cash for a given token (optionally per-market).
+
+        Boros deposits can sometimes show up as isolated cash for the target market;
+        this helper moves that isolated cash back to cross margin using cash_transfer.
+
+        Notes:
+        - cash_transfer uses 1e18 internal cash units, not token native decimals.
+        - This does NOT touch isolated positions for other markets unless market_id is None.
+        """
+        if self.simulation:
+            return True, {"status": "simulated"}
+
+        ok_state, state = await self.get_full_user_state(
+            token_id=int(token_id),
+            token_decimals=int(token_decimals),
+            include_open_orders=False,
+            include_withdrawal_status=False,
+        )
+        if not ok_state or not isinstance(state, dict):
+            return False, {"error": f"Failed to read Boros state: {state}"}
+
+        balances = state.get("balances") or {}
+        isolated_positions = balances.get("isolated_positions") or []
+        if not isinstance(isolated_positions, list):
+            isolated_positions = []
+
+        moved: list[dict[str, Any]] = []
+        for iso in isolated_positions:
+            try:
+                iso_market_id = int(iso.get("market_id"))
+                if market_id is not None and iso_market_id != int(market_id):
+                    continue
+                balance_wei = int(iso.get("balance_wei") or 0)
+                if balance_wei <= 0:
+                    continue
+
+                tx_ok, tx_res = await self.cash_transfer(
+                    market_id=iso_market_id,
+                    amount_wei=balance_wei,
+                    is_deposit=False,  # isolated -> cross
+                )
+                moved.append(
+                    {
+                        "market_id": iso_market_id,
+                        "balance_wei": balance_wei,
+                        "ok": tx_ok,
+                        "tx": tx_res,
+                    }
+                )
+                if not tx_ok:
+                    return False, {
+                        "error": f"Failed sweep isolated->cross for market {iso_market_id}",
+                        "moved": moved,
+                    }
+            except Exception as exc:  # noqa: BLE001
+                return False, {"error": f"Failed sweep isolated->cross: {exc}"}
+
+        return True, {"status": "ok", "moved": moved}
+
     @staticmethod
     def _unwrap_tx_payload(payload: dict[str, Any]) -> dict[str, Any]:
         """Best-effort unwrap of API payloads that may nest the tx dict."""
@@ -195,7 +309,6 @@ class BorosAdapter(BaseAdapter):
         self,
         calldata: dict[str, Any],
         *,
-        timeout: int = DEFAULT_TRANSACTION_TIMEOUT,
         max_retries: int = 2,
     ) -> tuple[bool, dict[str, Any]]:
         """Broadcast calldata from Boros API with retry logic.
@@ -292,14 +405,6 @@ class BorosAdapter(BaseAdapter):
             "attempts": max_retries + 1,
         }
 
-    async def connect(self) -> bool:
-        try:
-            markets = await self.boros_client.list_markets(limit=1)
-            return len(markets) > 0
-        except Exception as exc:
-            logger.error(f"BorosAdapter connection failed: {exc}")
-            return False
-
     # ------------------------------------------------------------------ #
     # Tick Math Utilities                                                  #
     # ------------------------------------------------------------------ #
@@ -1015,6 +1120,14 @@ class BorosAdapter(BaseAdapter):
         token_id: int,
         market_id: int,
     ) -> tuple[bool, dict[str, Any]]:
+        """Deposit collateral into Boros cross margin.
+
+        IMPORTANT: amount_wei is in the collateral token's native decimals.
+        Example: USDT has 6 decimals, so 1 USDT = 1_000_000.
+
+        After deposit, Boros may credit the cash as isolated for market_id. This
+        helper sweeps isolated -> cross for that market to match the method name.
+        """
         if self.simulation:
             logger.info(
                 f"[SIMULATION] deposit_to_cross_margin: {amount_wei} wei, "
@@ -1074,7 +1187,24 @@ class BorosAdapter(BaseAdapter):
                     "tx": tx_res,
                 }
 
-            return True, {"status": "ok", "approve": approve_res, "tx": tx_res}
+            sweep_ok, sweep_res = await self.sweep_isolated_to_cross(
+                token_id=int(token_id),
+                market_id=int(market_id),
+            )
+            if not sweep_ok:
+                return False, {
+                    "error": f"Deposit succeeded but isolated->cross sweep failed: {sweep_res}",
+                    "approve": approve_res,
+                    "tx": tx_res,
+                    "sweep": sweep_res,
+                }
+
+            return True, {
+                "status": "ok",
+                "approve": approve_res,
+                "tx": tx_res,
+                "sweep": sweep_res,
+            }
         except Exception as e:
             logger.error(f"Failed to deposit to cross margin: {e}")
             return False, {"error": str(e)}

wayfinder_paths/adapters/boros_adapter/client.py

@@ -250,10 +250,11 @@ class BorosClient:
 
         Args:
             token_id: Boros token ID (e.g., 3 for USDT).
-            amount_wei: Amount in scaled wei (1e18).
-            market_id: Target market ID.
-            user_address: User wallet address.
-            account_id: Boros account ID (0 = cross margin).
+            amount_wei: Amount in NATIVE token decimals (despite the param name).
+                Example: USDT has 6 decimals, so 1 USDT = 1_000_000.
+        market_id: Target market ID.
+        user_address: User wallet address.
+        account_id: Boros account ID (0 = cross margin).
 
         Returns:
             Calldata dictionary with 'to', 'data', 'value' fields.
@@ -283,7 +284,8 @@ class BorosClient:
 
         Args:
             token_id: Boros token ID.
-            amount_wei: Amount in scaled wei.
+            amount_wei: Amount in NATIVE token decimals (despite the param name).
+                Example: USDT has 6 decimals, so 1 USDT = 1_000_000.
             user_address: User wallet address.
             account_id: Account ID.
 

wayfinder_paths/adapters/boros_adapter/test_adapter.py

@@ -3,6 +3,7 @@
 from unittest.mock import AsyncMock, patch
 
 import pytest
+from eth_abi import encode as abi_encode
 
 from wayfinder_paths.adapters.boros_adapter.adapter import (
     BorosAdapter,
@@ -44,24 +45,6 @@ class TestBorosAdapter:
         """Test adapter has correct type."""
         assert adapter.adapter_type == "BOROS"
 
-    @pytest.mark.asyncio
-    async def test_connect_success(self, adapter, mock_boros_client):
-        """Test successful connection."""
-        mock_boros_client.list_markets = AsyncMock(
-            return_value=[{"marketId": 1, "symbol": "HYPE-USD"}]
-        )
-
-        result = await adapter.connect()
-        assert result is True
-
-    @pytest.mark.asyncio
-    async def test_connect_failure(self, adapter, mock_boros_client):
-        """Test connection failure."""
-        mock_boros_client.list_markets = AsyncMock(side_effect=Exception("API Error"))
-
-        result = await adapter.connect()
-        assert result is False
-
     @pytest.mark.asyncio
     async def test_list_markets_success(self, adapter, mock_boros_client):
         """Test successful market listing."""
@@ -358,6 +341,152 @@ class TestBorosAdapter:
         assert success is True
         assert result["status"] == "simulated"
 
+    @pytest.mark.asyncio
+    async def test_get_cash_fee_data_decodes_values(self, adapter):
+        """Test MarketHub.getCashFeeData decoding (on-chain read is mocked)."""
+        scaling_factor_wei = 123
+        fee_rate_wei = 5_000_000_000_000_000  # 0.005e18
+        min_cash_cross_wei = 400_000_000_000_000_000  # 0.4e18
+        min_cash_isolated_wei = 1_000_000_000_000_000_000  # 1.0e18
+        raw = abi_encode(
+            ["uint256", "uint256", "uint256", "uint256"],
+            [
+                scaling_factor_wei,
+                fee_rate_wei,
+                min_cash_cross_wei,
+                min_cash_isolated_wei,
+            ],
+        )
+
+        mock_web3 = AsyncMock()
+        mock_web3.eth.call = AsyncMock(return_value=raw)
+        mock_cm = AsyncMock()
+        mock_cm.__aenter__.return_value = mock_web3
+        mock_cm.__aexit__.return_value = False
+
+        with patch(
+            "wayfinder_paths.adapters.boros_adapter.adapter.web3_from_chain_id",
+            return_value=mock_cm,
+        ):
+            ok, data = await adapter.get_cash_fee_data(token_id=5)
+
+        assert ok is True
+        assert data["token_id"] == 5
+        assert data["scaling_factor_wei"] == scaling_factor_wei
+        assert data["fee_rate_wei"] == fee_rate_wei
+        assert data["min_cash_cross_wei"] == min_cash_cross_wei
+        assert data["min_cash_isolated_wei"] == min_cash_isolated_wei
+        assert data["fee_rate"] == pytest.approx(fee_rate_wei / 1e18)
+        assert data["min_cash_cross"] == pytest.approx(0.4)
+        assert data["min_cash_isolated"] == pytest.approx(1.0)
+
+    @pytest.mark.asyncio
+    async def test_sweep_isolated_to_cross_filters_by_market(self, adapter):
+        """Test isolated -> cross sweep only affects the specified market."""
+        adapter.simulation = False
+        adapter.get_full_user_state = AsyncMock(
+            return_value=(
+                True,
+                {
+                    "balances": {
+                        "isolated_positions": [
+                            {"market_id": 18, "balance_wei": 111},
+                            {"market_id": 19, "balance_wei": 222},
+                        ]
+                    }
+                },
+            )
+        )
+        adapter.cash_transfer = AsyncMock(return_value=(True, {"status": "ok"}))
+
+        ok, res = await adapter.sweep_isolated_to_cross(token_id=3, market_id=19)
+        assert ok is True
+        assert res["status"] == "ok"
+        assert len(res["moved"]) == 1
+        assert res["moved"][0]["market_id"] == 19
+        assert res["moved"][0]["balance_wei"] == 222
+
+        adapter.cash_transfer.assert_awaited_once_with(
+            market_id=19, amount_wei=222, is_deposit=False
+        )
+
+    @pytest.mark.asyncio
+    async def test_sweep_isolated_to_cross_errors_on_failed_transfer(self, adapter):
+        """Test sweep fails fast when an isolated->cross transfer fails."""
+        adapter.simulation = False
+        adapter.get_full_user_state = AsyncMock(
+            return_value=(
+                True,
+                {
+                    "balances": {
+                        "isolated_positions": [
+                            {"market_id": 18, "balance_wei": 111},
+                        ]
+                    }
+                },
+            )
+        )
+        adapter.cash_transfer = AsyncMock(return_value=(False, {"error": "nope"}))
+
+        ok, res = await adapter.sweep_isolated_to_cross(token_id=3, market_id=18)
+        assert ok is False
+        assert "Failed sweep isolated->cross" in res["error"]
+        assert res["moved"][0]["market_id"] == 18
+        assert res["moved"][0]["ok"] is False
+
+    @pytest.mark.asyncio
+    async def test_deposit_to_cross_margin_sweeps_after_deposit(
+        self, adapter, mock_boros_client
+    ):
+        """Test deposit triggers isolated->cross sweep on success (non-simulation path is mocked)."""
+        adapter.simulation = False
+        adapter.sign_callback = object()
+
+        mock_boros_client.build_deposit_calldata = AsyncMock(
+            return_value={
+                "to": "0x0000000000000000000000000000000000000002",
+                "data": "0xdeadbeef",
+                "value": 0,
+            }
+        )
+
+        with (
+            patch(
+                "wayfinder_paths.adapters.boros_adapter.adapter.build_approve_transaction",
+                new=AsyncMock(
+                    return_value={"to": "0x0", "data": "0x0", "chainId": 42161}
+                ),
+            ),
+            patch(
+                "wayfinder_paths.adapters.boros_adapter.adapter.send_transaction",
+                new=AsyncMock(return_value="0xapprove"),
+            ),
+            patch.object(
+                adapter,
+                "_broadcast_calldata",
+                new=AsyncMock(return_value=(True, {"tx_hash": "0xdeposit"})),
+            ),
+            patch.object(
+                adapter,
+                "sweep_isolated_to_cross",
+                new=AsyncMock(return_value=(True, {"status": "ok", "moved": []})),
+            ) as mock_sweep,
+        ):
+            ok, res = await adapter.deposit_to_cross_margin(
+                collateral_address="0x0000000000000000000000000000000000000001",
+                amount_wei=1_000_000,  # 1 USDT
+                token_id=3,
+                market_id=18,
+            )
+
+        assert ok is True
+        assert res["status"] == "ok"
+        assert res["approve"]["tx_hash"] == "0xapprove"
+        assert res["tx"]["tx_hash"] == "0xdeposit"
+        assert res["sweep"]["status"] == "ok"
+
+        mock_sweep.assert_awaited_once_with(token_id=3, market_id=18)
+
     @pytest.mark.asyncio
     async def test_withdraw_collateral_simulation(self, adapter):
         """Test withdraw in simulation mode."""

wayfinder_paths/adapters/hyperliquid_adapter/adapter.py

@@ -11,6 +11,7 @@ from loguru import logger
 
 from wayfinder_paths.core.adapters.BaseAdapter import BaseAdapter
 from wayfinder_paths.core.constants import ZERO_ADDRESS
+from wayfinder_paths.core.constants.contracts import HYPERCORE_SENTINEL_ADDRESS
 from wayfinder_paths.core.constants.hyperliquid import (
     ARBITRUM_USDC_ADDRESS as _ARBITRUM_USDC_ADDRESS,
 )
@@ -113,17 +114,6 @@ class HyperliquidAdapter(BaseAdapter):
         self._asset_to_sz_decimals: dict[int, int] | None = None
         self._coin_to_asset: dict[str, int] | None = None
 
-    async def connect(self) -> bool:
-        try:
-            meta = self.info.meta_and_asset_ctxs()
-            if meta:
-                self.logger.debug("HyperliquidAdapter connected successfully")
-                return True
-            return False
-        except Exception as exc:
-            self.logger.error(f"HyperliquidAdapter connection failed: {exc}")
-            return False
-
     # ------------------------------------------------------------------ #
     # Market Data - Read Operations                                       #
     # ------------------------------------------------------------------ #
@@ -714,7 +704,7 @@ class HyperliquidAdapter(BaseAdapter):
     @staticmethod
     def hypercore_index_to_system_address(index: int) -> str:
         if index == 150:
-            return "0x2222222222222222222222222222222222222222"
+            return HYPERCORE_SENTINEL_ADDRESS
 
         hex_index = f"{index:x}"
         padding_length = 42 - len("0x20") - len(hex_index)

wayfinder_paths/adapters/hyperliquid_adapter/exchange.py

@@ -1,9 +1,7 @@
-import json
 from decimal import Decimal
 from typing import Any, Literal
 
 from eth_account.messages import encode_typed_data
-from eth_utils import keccak
 from hyperliquid.api import API
 from hyperliquid.exchange import get_timestamp_ms
 from hyperliquid.info import Info
@@ -204,7 +202,7 @@ class Exchange:
             "time": nonce,
             "type": "withdraw3",
         }
-        payload = self._get_hypecore_user_signature_payload(
+        payload = user_signed_payload(
             "HyperliquidTransaction:Withdraw", WITHDRAW_SIGN_TYPES, action
         )
         if not (sig := await self.sign(payload, action, address)):
@@ -230,7 +228,7 @@ class Exchange:
             "amount": amount,
             "time": nonce,
         }
-        payload = self._get_hypecore_user_signature_payload(
+        payload = user_signed_payload(
             "HyperliquidTransaction:SpotSend", SPOT_TRANSFER_SIGN_TYPES, action
         )
         if not (sig := await self.sign(payload, action, address)):
@@ -248,7 +246,7 @@ class Exchange:
             "nonce": nonce,
             "type": "usdClassTransfer",
         }
-        payload = self._get_hypecore_user_signature_payload(
+        payload = user_signed_payload(
             "HyperliquidTransaction:UsdClassTransfer",
             USD_CLASS_TRANSFER_SIGN_TYPES,
             action,
@@ -268,7 +266,7 @@ class Exchange:
             "nonce": nonce,
             "type": "userDexAbstraction",
         }
-        payload = self._get_hypecore_user_signature_payload(
+        payload = user_signed_payload(
             "HyperliquidTransaction:UserDexAbstraction",
             USER_DEX_ABSTRACTION_SIGN_TYPES,
             action,
@@ -288,56 +286,26 @@ class Exchange:
             "nonce": nonce,
             "type": "approveBuilderFee",
         }
-        payload = self._get_hypecore_user_signature_payload(
+        payload = user_signed_payload(
             "HyperliquidTransaction:ApproveBuilderFee", BUILDER_FEE_SIGN_TYPES, action
         )
         if not (sig := await self.sign(payload, action, address)):
             return USER_DECLINED_ERROR
         return self._broadcast_hypecore(action, nonce, sig)
 
-    def build_sign(self, raw_payload: dict) -> str:
-        """Build and format the signing payload based on signing_type."""
-        if self.signing_type == "eip712":
-            # Remote signing: Return JSON string of typed data
-            return json.dumps(
-                raw_payload,
-                default=lambda o: (
-                    "0x" + o.hex() if isinstance(o, (bytes, bytearray)) else o
-                ),
-                separators=(",", ":"),
-            )
-        # Local signing: Return keccak hash
-        encoded = encode_typed_data(full_message=raw_payload)
-        full_msg = b"\x19" + encoded.version + encoded.header + encoded.body
-        return f"0x{keccak(full_msg).hex()}"
-
     async def sign(
         self, payload: str, action: dict, address: str
     ) -> dict[str, Any] | None:
         """Sign the payload and return Hyperliquid-format signature."""
         if self.signing_type == "eip712":
-            # For EIP-712: parse JSON, call callback with typed data dict, convert hex to {r,s,v}
-            typed_data = json.loads(payload)
-            sig_hex = await self.sign_callback(typed_data)
+            sig_hex = await self.sign_callback(payload)
             if not sig_hex:
                 return None
             return self.util._sig_hex_to_hl_signature(sig_hex)
 
-        # Local signing: payload is hash string, callback returns {r,s,v} directly
+        payload = encode_typed_data(full_message=payload)
         return await self.sign_callback(action, payload, address)
 
-    def _get_hypecore_l1_payload(
-        self, action, nonce, expires_after=None, is_mainnet=True
-    ):
-        """Build L1 action payload (orders, leverage, cancels)."""
-        payload = get_l1_action_payload(action, None, nonce, expires_after, is_mainnet)
-        return self.build_sign(payload)
-
-    def _get_hypecore_user_signature_payload(self, primary_type, payload_types, action):
-        """Build user signed action payload (withdrawals, transfers, etc.)."""
-        payload = user_signed_payload(primary_type, payload_types, action)
-        return self.build_sign(payload)
-
     def _broadcast_hypecore(self, action, nonce, signature):
         """Broadcast a signed action to the Hyperliquid exchange."""
         payload = {
@@ -351,7 +319,7 @@ class Exchange:
     async def sign_and_broadcast_hypecore(self, action, address):
         """Sign and broadcast an L1 action (orders, leverage, cancels)."""
         nonce = get_timestamp_ms()
-        payload = self._get_hypecore_l1_payload(action, nonce)
+        payload = payload = get_l1_action_payload(action, None, nonce, None, True)
         if not (sig := await self.sign(payload, action, address)):
             return USER_DECLINED_ERROR
         return self._broadcast_hypecore(action, nonce, sig)

wayfinder_paths/adapters/hyperliquid_adapter/local_signer.py

@@ -52,7 +52,7 @@ def create_local_signer(config: dict[str, Any]) -> HyperliquidSignCallback:
 
     # Create account
     pk = private_key if private_key.startswith("0x") else "0x" + private_key
-    account = Account.from_key(pk)
+    account: Account = Account.from_key(pk)
 
     async def sign(
         action: dict[str, Any], payload: str, address: str
@@ -76,7 +76,7 @@ def create_local_signer(config: dict[str, Any]) -> HyperliquidSignCallback:
             return None
 
         # Sign the hash
-        signed = account.signHash(payload)
+        signed = account.sign_message(payload)
         return {"r": hex(signed.r), "s": hex(signed.s), "v": signed.v}
 
     return sign

wayfinder_paths/adapters/multicall_adapter/adapter.py

@@ -7,9 +7,9 @@ from typing import Any
 from hexbytes import HexBytes
 
 from wayfinder_paths.core.adapters.BaseAdapter import BaseAdapter
+from wayfinder_paths.core.constants.contracts import MULTICALL3_ADDRESS
 from wayfinder_paths.core.constants.erc20_abi import ERC20_ABI
 
-MULTICALL3_DEFAULT_ADDRESS = "0xcA11bde05977b3631167028862bE2a173976CA11"
 MULTICALL3_ABI = [
     {
         "inputs": [
@@ -79,9 +79,7 @@ class MulticallAdapter(BaseAdapter):
         self.chain_id = int(chain_id) if chain_id is not None else None
         self.web3 = web3
 
-        checksum_address = self.web3.to_checksum_address(
-            address or MULTICALL3_DEFAULT_ADDRESS
-        )
+        checksum_address = self.web3.to_checksum_address(address or MULTICALL3_ADDRESS)
         self.contract = self.web3.eth.contract(
             address=checksum_address, abi=abi or MULTICALL3_ABI
         )

wayfinder_paths/core/clients/TokenClient.py

@@ -90,7 +90,7 @@ class FuzzyTokenResult(TypedDict):
 class TokenClient(WayfinderClient):
     def __init__(self):
         super().__init__()
-        self.api_base_url = f"{get_api_base_url()}/v1/blockchain/tokens"
+        self.api_base_url = f"{get_api_base_url()}/blockchain/tokens"
 
     async def get_token_details(
         self, query: str, market_data: bool = False, chain_id: int | None = None

wayfinder_paths/core/constants/__init__.py

@@ -33,6 +33,18 @@ from wayfinder_paths.core.constants.chains import (
     SUPPORTED_CHAINS,
 )
 from wayfinder_paths.core.constants.contracts import (
+    ENSO_ROUTER,
+    HYPE_FEE_WALLET,
+    HYPE_OFT_ADDRESS,
+    HYPERCORE_SENTINEL_ADDRESS,
+    HYPEREVM_WHYPE,
+    KHYPE_ADDRESS,
+    KHYPE_STAKING_ACCOUNTANT,
+    LHYPE_ACCOUNTANT,
+    LIFI_GENERIC,
+    LIFI_ROUTER_HYPEREVM,
+    LOOPED_HYPE_ADDRESS,
+    MULTICALL3_ADDRESS,
     NATIVE_TOKEN_SENTINEL,
     ZERO_ADDRESS,
 )
@@ -42,7 +54,6 @@ from .hyperliquid import (
     ARBITRUM_USDC_TOKEN_ID,
     DEFAULT_HYPERLIQUID_BUILDER_FEE,
     DEFAULT_HYPERLIQUID_BUILDER_FEE_TENTHS_BP,
-    HYPE_FEE_WALLET,
     HYPERLIQUID_BRIDGE_ADDRESS,
 )
 
@@ -85,4 +96,15 @@ __all__ = [
     "HYPE_FEE_WALLET",
     "DEFAULT_HYPERLIQUID_BUILDER_FEE_TENTHS_BP",
     "DEFAULT_HYPERLIQUID_BUILDER_FEE",
+    "ENSO_ROUTER",
+    "HYPE_OFT_ADDRESS",
+    "HYPERCORE_SENTINEL_ADDRESS",
+    "HYPEREVM_WHYPE",
+    "KHYPE_ADDRESS",
+    "KHYPE_STAKING_ACCOUNTANT",
+    "LHYPE_ACCOUNTANT",
+    "LIFI_GENERIC",
+    "LIFI_ROUTER_HYPEREVM",
+    "LOOPED_HYPE_ADDRESS",
+    "MULTICALL3_ADDRESS",
 ]

wayfinder_paths/core/constants/contracts.py

@@ -45,6 +45,28 @@ USDT_ETHEREUM = to_checksum_address("0xdAC17F958D2ee523a2206206994597C13D831ec7"
 USDT_POLYGON = to_checksum_address("0xc2132D05D31c914a87C6611C10748AEb04B58e8F")
 USDT_BSC = to_checksum_address("0x55d398326f99059fF775485246999027B3197955")
 
+HYPE_FEE_WALLET = to_checksum_address("0xaA1D89f333857eD78F8434CC4f896A9293EFE65c")
+
+# HyperEVM token addresses
+KHYPE_ADDRESS = to_checksum_address("0xfD739d4e423301CE9385c1fb8850539D657C296D")
+LOOPED_HYPE_ADDRESS = to_checksum_address("0x5748ae796AE46A4F1348a1693de4b50560485562")
+
+# Accountant contracts for exchange rate calculations
+KHYPE_STAKING_ACCOUNTANT = to_checksum_address(
+    "0x9209648Ec9D448EF57116B73A2f081835643dc7A"
+)
+LHYPE_ACCOUNTANT = to_checksum_address("0xcE621a3CA6F72706678cFF0572ae8d15e5F001c3")
+
+# LayerZero OFT bridge (HyperEVM native HYPE -> Arbitrum OFT HYPE)
+HYPE_OFT_ADDRESS = to_checksum_address("0x007C26Ed5C33Fe6fEF62223d4c363A01F1b1dDc1")
+
+# Multicall3 (deployed at same address on all EVM chains)
+MULTICALL3_ADDRESS = to_checksum_address("0xcA11bde05977b3631167028862bE2a173976CA11")
+
+# LI.FI routers
+LIFI_ROUTER_HYPEREVM = to_checksum_address("0x0a0758d937d1059c356D4714e57F5df0239bce1A")
+LIFI_GENERIC = to_checksum_address("0x31a9b1835864706Af10103b31Ea2b79bdb995F5F")
+
 TOKENS_REQUIRING_APPROVAL_RESET: set[tuple[int, str]] = {
     (1, USDT_ETHEREUM),
     (137, USDT_POLYGON),