wayfinder-paths 0.1.28__py3-none-any.whl → 0.1.30__py3-none-any.whl

wayfinder_paths/adapters/boros_adapter/test_adapter.py

@@ -1,8 +1,10 @@
 """Tests for BorosAdapter."""
 
-from unittest.mock import AsyncMock, patch
+from types import SimpleNamespace
+from unittest.mock import AsyncMock, MagicMock, patch
 
 import pytest
+from eth_abi import encode as abi_encode
 
 from wayfinder_paths.adapters.boros_adapter.adapter import (
     BorosAdapter,
@@ -44,24 +46,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 +342,262 @@ 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_account_balances = AsyncMock(
+            return_value=(
+                True,
+                {
+                    "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_account_balances = AsyncMock(
+            return_value=(
+                True,
+                {
+                    "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_close_positions_except_skips_keep_market(self, adapter):
+        adapter.simulation = False
+        adapter.close_positions_market = AsyncMock(
+            return_value=(True, {"status": "ok"})
+        )
+
+        ok, res = await adapter.close_positions_except(
+            keep_market_id=19, token_id=3, market_ids=[18, 19, 20]
+        )
+        assert ok is True
+        assert res["status"] == "ok"
+
+        calls = adapter.close_positions_market.await_args_list
+        assert len(calls) == 2
+        assert calls[0].args[0] == 18
+        assert calls[1].args[0] == 20
+
+    @pytest.mark.asyncio
+    async def test_ensure_position_size_yu_increases_short(self, adapter):
+        adapter.simulation = False
+        adapter.get_active_positions = AsyncMock(return_value=(True, []))
+        adapter.place_rate_order = AsyncMock(return_value=(True, {"tx_hash": "0xopen"}))
+
+        ok, res = await adapter.ensure_position_size_yu(
+            market_id=18, token_id=3, target_size_yu=1.5
+        )
+        assert ok is True
+        assert res["action"] == "increase_short"
+        adapter.place_rate_order.assert_awaited_once()
+
+        _, kwargs = adapter.place_rate_order.await_args
+        assert kwargs["market_id"] == 18
+        assert kwargs["token_id"] == 3
+        assert kwargs["side"] == "short"
+        assert kwargs["tif"] == "IOC"
+        assert kwargs["size_yu_wei"] == int(1.5 * 1e18)
+
+    @pytest.mark.asyncio
+    async def test_ensure_position_size_yu_decreases(self, adapter):
+        adapter.simulation = False
+        adapter.get_active_positions = AsyncMock(
+            return_value=(True, [{"size": 2.0, "sizeWei": int(2e18)}])
+        )
+        adapter.close_positions_market = AsyncMock(
+            return_value=(True, {"tx_hash": "0xclose"})
+        )
+
+        ok, res = await adapter.ensure_position_size_yu(
+            market_id=18, token_id=3, target_size_yu=1.0
+        )
+        assert ok is True
+        assert res["action"] == "decrease"
+        adapter.close_positions_market.assert_awaited_once_with(
+            market_id=18, token_id=3, size_yu_wei=int(1.0 * 1e18)
+        )
+
+    @pytest.mark.asyncio
+    async def test_bridge_hype_oft_rounds_amount_and_builds_tx(self, adapter):
+        adapter.simulation = False
+        adapter.sign_callback = object()
+
+        mock_contract = SimpleNamespace()
+        mock_dec_fn = SimpleNamespace(call=AsyncMock(return_value=10))
+        mock_quote_fn = SimpleNamespace(call=AsyncMock(return_value=(5, 0)))
+        mock_functions = SimpleNamespace(
+            decimalConversionRate=MagicMock(return_value=mock_dec_fn),
+            quoteSend=MagicMock(return_value=mock_quote_fn),
+        )
+        mock_contract.functions = mock_functions
+
+        mock_web3 = SimpleNamespace(
+            eth=SimpleNamespace(contract=MagicMock(return_value=mock_contract)),
+            to_checksum_address=lambda x: x,
+        )
+        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,
+            ),
+            patch(
+                "wayfinder_paths.adapters.boros_adapter.adapter.encode_call",
+                new=AsyncMock(return_value={"chainId": 999}),
+            ) as mock_encode,
+            patch(
+                "wayfinder_paths.adapters.boros_adapter.adapter.send_transaction",
+                new=AsyncMock(return_value="0xtx"),
+            ),
+        ):
+            ok, res = await adapter.bridge_hype_oft_hyperevm_to_arbitrum(
+                amount_wei=123,
+                max_value_wei=1000,
+                to_address=adapter.user_address,
+                from_address=adapter.user_address,
+            )
+
+        assert ok is True
+        assert res["status"] == "ok"
+        assert res["tx_hash"] == "0xtx"
+        assert res["amount_wei"] == 120  # rounded down by conversion rate 10
+        assert res["native_fee_wei"] == 5
+        assert res["total_value_wei"] == 125
+
+        _, kwargs = mock_encode.await_args
+        assert kwargs["fn_name"] == "send"
+        assert kwargs["value"] == 125
+        send_params = kwargs["args"][0]
+        assert send_params[0] == 30110
+        assert send_params[2] == 120
+
     @pytest.mark.asyncio
     async def test_withdraw_collateral_simulation(self, adapter):
         """Test withdraw in simulation mode."""

wayfinder_paths/adapters/hyperliquid_adapter/adapter.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 
 import asyncio
 import time
+from collections.abc import Awaitable, Callable
 from decimal import ROUND_DOWN, Decimal, getcontext
 from typing import Any
 
@@ -11,6 +12,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,
 )
@@ -21,7 +23,6 @@ from wayfinder_paths.core.constants.hyperliquid import (
 from wayfinder_paths.core.constants.hyperliquid import (
     HYPERLIQUID_BRIDGE_ADDRESS as _HYPERLIQUID_BRIDGE_ADDRESS,
 )
-from wayfinder_paths.core.types import HyperliquidSignCallback
 
 # Re-export Bridge2 constants for backwards compatibility.
 HYPERLIQUID_BRIDGE_ADDRESS = _HYPERLIQUID_BRIDGE_ADDRESS
@@ -67,7 +68,7 @@ class HyperliquidAdapter(BaseAdapter):
         config: dict[str, Any] | None = None,
         *,
         simulation: bool = False,
-        sign_callback: HyperliquidSignCallback | None = None,
+        sign_callback: Callable[[dict], Awaitable[str]] | None = None,
     ) -> None:
         super().__init__("hyperliquid_adapter", config)
 
@@ -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,3 +1,4 @@
+from collections.abc import Awaitable, Callable
 from decimal import Decimal
 from typing import Any, Literal
 
@@ -24,7 +25,6 @@ from loguru import logger
 from web3 import Web3
 
 from wayfinder_paths.adapters.hyperliquid_adapter.util import Util
-from wayfinder_paths.core.types import HyperliquidSignCallback
 
 ARBITRUM_CHAIN_ID = "0xa4b1"
 MAINNET = "Mainnet"
@@ -39,7 +39,7 @@ class Exchange:
         self,
         info: Info,
         util: Util,
-        sign_callback: HyperliquidSignCallback,
+        sign_callback: Callable[[dict], Awaitable[str]],
         signing_type: Literal["eip712", "local"],
     ):
         self.info = info

wayfinder_paths/adapters/hyperliquid_adapter/local_signer.py

@@ -1,9 +1,8 @@
+from collections.abc import Awaitable, Callable
 from typing import Any
 
 from eth_account import Account
 
-from wayfinder_paths.core.types import HyperliquidSignCallback
-
 
 def _resolve_private_key(config: dict[str, Any]) -> str | None:
     """Extract private key from config."""
@@ -26,23 +25,7 @@ def _resolve_private_key(config: dict[str, Any]) -> str | None:
     return None
 
 
-def create_local_signer(config: dict[str, Any]) -> HyperliquidSignCallback:
-    """
-    Create a Hyperliquid signing callback using private key from config.
-
-    For local signing, the payload is a keccak hash (0x...) of the encoded EIP-712 typed data.
-    The callback signs with the private key and returns a signature dict.
-
-    Args:
-        config: Configuration dict containing private key in strategy_wallet or main_wallet
-
-    Returns:
-        HyperliquidSignCallback that signs payloads with the local private key
-
-    Raises:
-        ValueError: If no private key found in config
-    """
-    # Extract private key from config
+def create_local_signer(config: dict[str, Any]) -> Callable[[dict], Awaitable[str]]:
     private_key = _resolve_private_key(config)
     if not private_key:
         raise ValueError(
@@ -57,20 +40,6 @@ def create_local_signer(config: dict[str, Any]) -> HyperliquidSignCallback:
     async def sign(
         action: dict[str, Any], payload: str, address: str
     ) -> dict[str, str] | None:
-        """
-        Sign a Hyperliquid action with local private key.
-
-        For local signing, payload is keccak hash (0x...) of encoded typed data.
-        Sign with account and return signature dict.
-
-        Args:
-            action: The action being signed (not used for local signing)
-            payload: Keccak hash (0x...) of encoded EIP-712 typed data
-            address: The address signing (validation check)
-
-        Returns:
-            Signature dict {"r": "0x...", "s": "0x...", "v": 28} or None if validation fails
-        """
         # Verify address matches account
         if address.lower() != account.address.lower():
             return None

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),