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

wayfinder_paths/adapters/boros_adapter/adapter.py

@@ -10,9 +10,15 @@ 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.contracts import BOROS_MARKET_HUB, BOROS_ROUTER
+from wayfinder_paths.core.constants.chains import CHAIN_ID_HYPEREVM
+from wayfinder_paths.core.constants.contracts import (
+    BOROS_MARKET_HUB,
+    BOROS_ROUTER,
+    HYPE_OFT_ADDRESS,
+)
+from wayfinder_paths.core.constants.hype_oft_abi import HYPE_OFT_ABI
 from wayfinder_paths.core.utils.tokens import build_approve_transaction
-from wayfinder_paths.core.utils.transaction import send_transaction
+from wayfinder_paths.core.utils.transaction import encode_call, send_transaction
 from wayfinder_paths.core.utils.web3 import web3_from_chain_id
 
 from .client import BorosClient
@@ -114,6 +120,11 @@ class BorosAdapter(BaseAdapter):
         }
     ]
 
+    @staticmethod
+    def _pad_address_bytes32(address: str) -> bytes:
+        checksum = to_checksum_address(address)
+        return bytes.fromhex(checksum[2:]).rjust(32, b"\x00")
+
     async def get_cash_fee_data(self, *, token_id: int) -> tuple[bool, dict[str, Any]]:
         """Read MarketHub.getCashFeeData(tokenId) from chain.
 
@@ -168,7 +179,6 @@ class BorosAdapter(BaseAdapter):
         *,
         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).
 
@@ -176,22 +186,17 @@ class BorosAdapter(BaseAdapter):
         this helper moves that isolated cash back to cross margin using cash_transfer.
 
         Notes:
+        - Uses `get_account_balances()` (collaterals endpoint) to find isolated cash.
         - 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}"}
+        ok_bal, balances = await self.get_account_balances(token_id=int(token_id))
+        if not ok_bal or not isinstance(balances, dict):
+            return False, {"error": f"Failed to read Boros balances: {balances}"}
 
-        balances = state.get("balances") or {}
         isolated_positions = balances.get("isolated_positions") or []
         if not isinstance(isolated_positions, list):
             isolated_positions = []
@@ -1304,6 +1309,302 @@ class BorosAdapter(BaseAdapter):
             logger.error(f"Failed to cash transfer: {e}")
             return False, {"error": str(e)}
 
+    async def bridge_hype_oft_hyperevm_to_arbitrum(
+        self,
+        *,
+        amount_wei: int,
+        max_value_wei: int | None = None,
+        to_address: str | None = None,
+        from_address: str | None = None,
+        dst_eid: int = 30110,
+        min_amount_wei: int = 0,
+    ) -> tuple[bool, dict[str, Any]]:
+        """Bridge native HYPE from HyperEVM -> Arbitrum via LayerZero OFT.
+
+        Notes:
+        - Uses HyperEVM chain id (999) for the transaction.
+        - `amount_wei` is in 1e18 (native HYPE).
+        - The OFT bridge requires `msg.value = amount + nativeFee`.
+        - Amount must be rounded down to `decimalConversionRate()`.
+        - If `max_value_wei` is provided, clamps amount so that (amount + fee) <= max_value_wei.
+        """
+        if amount_wei <= 0:
+            return True, {"status": "no_op", "amount_wei": 0}
+
+        if self.simulation:
+            return True, {
+                "status": "simulated",
+                "amount_wei": int(amount_wei),
+                "dst_eid": int(dst_eid),
+                "to": to_address or self.user_address,
+            }
+
+        if not self.sign_callback:
+            return False, {"error": "sign_callback not configured"}
+
+        sender = from_address or self.user_address
+        recipient = to_address or self.user_address
+        if not sender or not recipient:
+            return False, {"error": "from_address/to_address not configured"}
+
+        try:
+            async with web3_from_chain_id(CHAIN_ID_HYPEREVM) 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()
+                )
+                if conversion_rate > 0:
+                    amount_wei = (int(amount_wei) // conversion_rate) * conversion_rate
+                else:
+                    amount_wei = int(amount_wei)
+
+                if amount_wei <= 0:
+                    return True, {"status": "no_op", "amount_wei": 0}
+
+                to_bytes32 = self._pad_address_bytes32(recipient)
+
+                def _send_params(amount_ld: int) -> tuple[Any, ...]:
+                    return (
+                        int(dst_eid),
+                        to_bytes32,
+                        int(amount_ld),
+                        int(min_amount_wei),
+                        b"",
+                        b"",
+                        b"",
+                    )
+
+                send_params = _send_params(int(amount_wei))
+                fee = await contract.functions.quoteSend(send_params, False).call()
+                native_fee_wei = int(fee[0])
+                lz_token_fee_wei = int(fee[1])
+
+                if max_value_wei is not None:
+                    max_send_amount_wei = max(0, int(max_value_wei) - native_fee_wei)
+                    if conversion_rate > 0:
+                        max_send_amount_wei = (
+                            max_send_amount_wei // conversion_rate
+                        ) * conversion_rate
+                    if amount_wei > max_send_amount_wei:
+                        amount_wei = int(max_send_amount_wei)
+                        if amount_wei <= 0:
+                            return False, {
+                                "error": "Insufficient balance to cover OFT fee",
+                                "native_fee_wei": native_fee_wei,
+                                "max_value_wei": int(max_value_wei),
+                            }
+                        send_params = _send_params(int(amount_wei))
+                        fee = await contract.functions.quoteSend(
+                            send_params, False
+                        ).call()
+                        native_fee_wei = int(fee[0])
+                        lz_token_fee_wei = int(fee[1])
+
+                total_value_wei = int(amount_wei) + int(native_fee_wei)
+                if max_value_wei is not None and total_value_wei > int(max_value_wei):
+                    return False, {
+                        "error": "Insufficient balance after fee quote",
+                        "amount_wei": int(amount_wei),
+                        "native_fee_wei": int(native_fee_wei),
+                        "total_value_wei": int(total_value_wei),
+                        "max_value_wei": int(max_value_wei),
+                    }
+
+            tx = await encode_call(
+                target=HYPE_OFT_ADDRESS,
+                abi=HYPE_OFT_ABI,
+                fn_name="send",
+                args=[
+                    send_params,
+                    (int(native_fee_wei), int(lz_token_fee_wei)),
+                    to_checksum_address(sender),
+                ],
+                from_address=sender,
+                chain_id=CHAIN_ID_HYPEREVM,
+                value=int(total_value_wei),
+            )
+            tx_hash = await send_transaction(
+                tx, self.sign_callback, wait_for_receipt=True
+            )
+            return True, {
+                "status": "ok",
+                "tx_hash": tx_hash,
+                "amount_wei": int(amount_wei),
+                "native_fee_wei": int(native_fee_wei),
+                "lz_token_fee_wei": int(lz_token_fee_wei),
+                "total_value_wei": int(total_value_wei),
+                "dst_eid": int(dst_eid),
+                "to": recipient,
+                "from": sender,
+                "layerzeroscan": f"https://layerzeroscan.com/tx/{tx_hash}",
+            }
+        except Exception as exc:  # noqa: BLE001
+            return False, {"error": str(exc)}
+
+    async def close_positions_except(
+        self,
+        *,
+        keep_market_id: int,
+        token_id: int = 3,
+        market_ids: list[int] | None = None,
+        best_effort: bool = True,
+    ) -> tuple[bool, dict[str, Any]]:
+        """Close all Boros positions except `keep_market_id` (best-effort by default)."""
+        if self.simulation:
+            return True, {
+                "status": "simulated",
+                "keep_market_id": int(keep_market_id),
+                "markets": market_ids or [],
+            }
+
+        if market_ids is None:
+            ok_pos, positions = await self.get_active_positions()
+            if not ok_pos:
+                return False, {"error": f"Failed to get positions: {positions}"}
+            market_ids = sorted(
+                {
+                    int(p.get("marketId"))
+                    for p in positions
+                    if p.get("marketId") is not None
+                }
+            )
+
+        results: list[dict[str, Any]] = []
+        failures: list[dict[str, Any]] = []
+        for mid in market_ids:
+            if int(mid) == int(keep_market_id):
+                continue
+            ok_close, res_close = await self.close_positions_market(
+                int(mid), token_id=int(token_id)
+            )
+            entry = {"market_id": int(mid), "ok": bool(ok_close), "res": res_close}
+            results.append(entry)
+            if not ok_close:
+                failures.append(entry)
+                if not best_effort:
+                    return False, {
+                        "error": f"Failed to close position for market {mid}",
+                        "results": results,
+                    }
+
+        return True, {"status": "ok", "results": results, "failures": failures}
+
+    async def ensure_position_size_yu(
+        self,
+        *,
+        market_id: int,
+        token_id: int,
+        target_size_yu: float,
+        tif: str = "IOC",
+        min_resize_excess_usd: float | None = None,
+        yu_to_usd: float | None = None,
+    ) -> tuple[bool, dict[str, Any]]:
+        """Ensure the Boros position size (YU) for a market.
+
+        - Uses `place_rate_order(... side="short")` to increase the position.
+        - Uses `close_positions_market(..., size_yu_wei=...)` to decrease it.
+        - If `min_resize_excess_usd` is provided, uses `yu_to_usd` to skip small resizes.
+        """
+        if self.simulation:
+            return True, {
+                "status": "simulated",
+                "market_id": int(market_id),
+                "token_id": int(token_id),
+                "target_size_yu": float(target_size_yu),
+            }
+
+        ok_pos, positions = await self.get_active_positions(market_id=int(market_id))
+        if not ok_pos:
+            return False, {"error": f"Failed to get positions: {positions}"}
+
+        if positions:
+            current_size_yu = abs(float(positions[0].get("size", 0) or 0.0))
+        else:
+            current_size_yu = 0.0
+
+        diff_yu = float(target_size_yu) - float(current_size_yu)
+        diff_abs_yu = abs(diff_yu)
+
+        if min_resize_excess_usd is not None:
+            if yu_to_usd is None or yu_to_usd <= 0:
+                return False, {
+                    "error": "yu_to_usd required when min_resize_excess_usd is set",
+                    "yu_to_usd": yu_to_usd,
+                }
+            diff_usd_equiv = diff_abs_yu * float(yu_to_usd)
+            if diff_usd_equiv < float(min_resize_excess_usd):
+                return True, {
+                    "status": "ok",
+                    "action": "no_op",
+                    "market_id": int(market_id),
+                    "token_id": int(token_id),
+                    "current_size_yu": float(current_size_yu),
+                    "target_size_yu": float(target_size_yu),
+                    "diff_yu": float(diff_yu),
+                }
+
+        if diff_abs_yu < 1e-9:
+            return True, {
+                "status": "ok",
+                "action": "no_op",
+                "market_id": int(market_id),
+                "token_id": int(token_id),
+                "current_size_yu": float(current_size_yu),
+                "target_size_yu": float(target_size_yu),
+                "diff_yu": float(diff_yu),
+            }
+
+        size_yu_wei = int(diff_abs_yu * 1e18)
+
+        if diff_yu > 0:
+            ok_open, res_open = await self.place_rate_order(
+                market_id=int(market_id),
+                token_id=int(token_id),
+                size_yu_wei=int(size_yu_wei),
+                side="short",
+                tif=tif,
+            )
+            if not ok_open:
+                return False, {
+                    "error": f"Failed to open/increase position: {res_open}",
+                    "market_id": int(market_id),
+                }
+            return True, {
+                "status": "ok",
+                "action": "increase_short",
+                "market_id": int(market_id),
+                "token_id": int(token_id),
+                "current_size_yu": float(current_size_yu),
+                "target_size_yu": float(target_size_yu),
+                "diff_yu": float(diff_yu),
+                "tx": res_open,
+            }
+
+        ok_close, res_close = await self.close_positions_market(
+            market_id=int(market_id),
+            token_id=int(token_id),
+            size_yu_wei=int(size_yu_wei),
+        )
+        if not ok_close:
+            return False, {
+                "error": f"Failed to close/decrease position: {res_close}",
+                "market_id": int(market_id),
+            }
+        return True, {
+            "status": "ok",
+            "action": "decrease",
+            "market_id": int(market_id),
+            "token_id": int(token_id),
+            "current_size_yu": float(current_size_yu),
+            "target_size_yu": float(target_size_yu),
+            "diff_yu": float(diff_yu),
+            "tx": res_close,
+        }
+
     async def place_rate_order(
         self,
         *,

wayfinder_paths/adapters/boros_adapter/test_adapter.py

@@ -1,6 +1,7 @@
 """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
@@ -384,16 +385,14 @@ class TestBorosAdapter:
     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(
+        adapter.get_account_balances = AsyncMock(
             return_value=(
                 True,
                 {
-                    "balances": {
-                        "isolated_positions": [
-                            {"market_id": 18, "balance_wei": 111},
-                            {"market_id": 19, "balance_wei": 222},
-                        ]
-                    }
+                    "isolated_positions": [
+                        {"market_id": 18, "balance_wei": 111},
+                        {"market_id": 19, "balance_wei": 222},
+                    ]
                 },
             )
         )
@@ -414,15 +413,13 @@ class TestBorosAdapter:
     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(
+        adapter.get_account_balances = AsyncMock(
             return_value=(
                 True,
                 {
-                    "balances": {
-                        "isolated_positions": [
-                            {"market_id": 18, "balance_wei": 111},
-                        ]
-                    }
+                    "isolated_positions": [
+                        {"market_id": 18, "balance_wei": 111},
+                    ]
                 },
             )
         )
@@ -487,6 +484,120 @@ class TestBorosAdapter:
 
         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
 
@@ -22,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
@@ -68,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)
 

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