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

wayfinder_paths/strategies/boros_hype_strategy/risk_ops_mixin.py

@@ -16,6 +16,7 @@ from wayfinder_paths.adapters.hyperliquid_adapter.paired_filler import PairedFil
 
 from .constants import (
     BOROS_HYPE_MARKET_ID,
+    BOROS_HYPE_TOKEN_ID,
     HYPE_NATIVE,
     KHYPE_LST,
     LOOPED_HYPE,
@@ -415,17 +416,26 @@ class BorosHypeRiskOpsMixin:
                     and float(inv_final.boros_pending_withdrawal_usd) <= 0.0
                 )
                 if boros_enabled and spot_usd >= 10.0 and self.boros_adapter:
-                    target_usd = spot_usd * float(
-                        self._planner_config.boros_coverage_target
-                    )
                     market_id = (
                         self._planner_runtime.current_boros_market_id
                         or BOROS_HYPE_MARKET_ID
                     )
+                    token_id = int(
+                        self._planner_runtime.current_boros_token_id
+                        or BOROS_HYPE_TOKEN_ID
+                    )
+                    if token_id == BOROS_HYPE_TOKEN_ID:
+                        target_yu = float(inv_final.total_hype_exposure) * float(
+                            self._planner_config.boros_coverage_target
+                        )
+                    else:
+                        target_yu = spot_usd * float(
+                            self._planner_config.boros_coverage_target
+                        )
                     ok_boros, msg_boros = await self._ensure_boros_position(
                         {
                             "market_id": int(market_id),
-                            "target_size_usd": float(target_usd),
+                            "target_size_yu": float(target_yu),
                         },
                         inv_final,
                     )
@@ -721,32 +731,40 @@ class BorosHypeRiskOpsMixin:
                             slippage=0.01,
                             strategy_name="boros_hype_strategy",
                         )
+                        trim_usd -= lhype_trim_usd
                         await asyncio.sleep(2)
                     except Exception as exc:  # noqa: BLE001
                         logger.warning(f"Failed to sell looped HYPE: {exc}")
 
-        ok_hype, hype_raw = await self.balance_adapter.get_vault_wallet_balance(
-            HYPE_NATIVE
-        )
-        hype_raw_int = (
-            int(hype_raw) if ok_hype and hype_raw and int(hype_raw) > 0 else 0
-        )
-        gas_reserve_wei = int(float(MIN_HYPE_GAS) * 1e18)
-        hype_to_transfer_raw = max(0, hype_raw_int - gas_reserve_wei)
-        if hype_to_transfer_raw < int(0.01 * 1e18):
-            return True, "No HYPE to transfer after trim"
-
-        destination = HyperliquidAdapter.hypercore_index_to_system_address(150)
-        ok_send, send_res = await self.balance_adapter.send_to_address(
-            token_id=HYPE_NATIVE,
-            amount=int(hype_to_transfer_raw),
-            from_wallet=strategy_wallet,
-            to_address=destination,
-            signing_callback=self._sign_callback,
-        )
-        if not ok_send:
-            return False, f"Failed to transfer HYPE to Hyperliquid: {send_res}"
-        await asyncio.sleep(3)
+        remaining_trim_usd = max(0.0, float(trim_usd))
+
+        # If we still need to trim, move just enough HYPE from HyperEVM -> HL spot so we
+        # can sell it for USDC and add to perp margin (avoid transferring all HYPE).
+        if remaining_trim_usd > 1.0:
+            ok_hype, hype_raw = await self.balance_adapter.get_vault_wallet_balance(
+                HYPE_NATIVE
+            )
+            hype_raw_int = (
+                int(hype_raw) if ok_hype and hype_raw and int(hype_raw) > 0 else 0
+            )
+            gas_reserve_wei = int(float(MIN_HYPE_GAS) * 1e18)
+            transferable_raw = max(0, hype_raw_int - gas_reserve_wei)
+            transferable_tokens = float(transferable_raw) / 1e18
+
+            desired_tokens = min(transferable_tokens, remaining_trim_usd / hype_price)
+            hype_to_transfer_raw = int(desired_tokens * 1e18)
+            if hype_to_transfer_raw >= int(0.01 * 1e18):
+                destination = HyperliquidAdapter.hypercore_index_to_system_address(150)
+                ok_send, send_res = await self.balance_adapter.send_to_address(
+                    token_id=HYPE_NATIVE,
+                    amount=int(hype_to_transfer_raw),
+                    from_wallet=strategy_wallet,
+                    to_address=destination,
+                    signing_callback=self._sign_callback,
+                )
+                if not ok_send:
+                    return False, f"Failed to transfer HYPE to Hyperliquid: {send_res}"
+                await asyncio.sleep(3)
 
         try:
             spot_asset_id, perp_asset_id = await self._get_hype_asset_ids()
@@ -764,9 +782,10 @@ class BorosHypeRiskOpsMixin:
                         spot_hype_balance = available
                         break
 
-            if spot_hype_balance > 0.01:
+            if spot_hype_balance > 0.01 and remaining_trim_usd > 1.0:
+                desired_units = min(spot_hype_balance, remaining_trim_usd / hype_price)
                 rounded_units = self.hyperliquid_adapter.get_valid_order_size(
-                    int(spot_asset_id), spot_hype_balance
+                    int(spot_asset_id), desired_units
                 )
                 if rounded_units > 0:
                     if (
@@ -811,6 +830,9 @@ class BorosHypeRiskOpsMixin:
                             builder=self.builder_fee,
                         )
                         await asyncio.sleep(2)
+                    remaining_trim_usd = max(
+                        0.0, remaining_trim_usd - float(rounded_units) * hype_price
+                    )
         except Exception as exc:  # noqa: BLE001
             logger.warning(f"Failed to sell spot HYPE: {exc}")
 

wayfinder_paths/strategies/boros_hype_strategy/strategy.py

@@ -28,9 +28,6 @@ from wayfinder_paths.adapters.brap_adapter.adapter import BRAPAdapter
 from wayfinder_paths.adapters.hyperliquid_adapter.adapter import (
     HyperliquidAdapter,
 )
-from wayfinder_paths.adapters.hyperliquid_adapter.executor import (
-    LocalHyperliquidExecutor,
-)
 from wayfinder_paths.adapters.ledger_adapter.adapter import LedgerAdapter
 from wayfinder_paths.core.constants.hyperliquid import (
     DEFAULT_HYPERLIQUID_BUILDER_FEE_TENTHS_BP,
@@ -61,6 +58,7 @@ from wayfinder_paths.core.strategies.descriptors import (
 from .boros_ops_mixin import BorosHypeBorosOpsMixin
 from .constants import (
     BOROS_HYPE_TOKEN_ID,
+    BOROS_MIN_DEPOSIT_HYPE,
     ETH_ARB,
     MIN_HYPE_GAS,
     MIN_NET_DEPOSIT,
@@ -176,15 +174,11 @@ class BorosHypeStrategy(
         self,
         config: dict[str, Any] | None = None,
         *,
-        main_wallet: dict[str, Any] | None = None,
-        strategy_wallet: dict[str, Any] | None = None,
         simulation: bool = False,
         **kwargs,
     ) -> None:
         super().__init__(
             config=config,
-            main_wallet=main_wallet,
-            strategy_wallet=strategy_wallet,
             **kwargs,
         )
 
@@ -291,22 +285,13 @@ class BorosHypeStrategy(
             )
 
         # Initialize Hyperliquid adapter for market data and perp trading
+        # The adapter will create Exchange internally with local signer from config
+        # if no sign_callback is provided (and not in simulation mode).
         try:
-            # Create executor for non-simulation mode (requires private key)
-            hl_executor = None
-            if not self.simulation:
-                try:
-                    hl_executor = LocalHyperliquidExecutor(config=self._config)
-                    logger.info(
-                        f"Hyperliquid executor initialized for {hl_executor.address}"
-                    )
-                except (ImportError, ValueError) as e:
-                    logger.warning(f"Hyperliquid executor not available: {e}")
-
             self.hyperliquid_adapter = HyperliquidAdapter(
                 config=self._config,
                 simulation=self.simulation,
-                executor=hl_executor,
+                sign_callback=self.strategy_sign_typed_data,
             )
             try:
                 hl_connected = await self.hyperliquid_adapter.connect()
@@ -654,6 +639,12 @@ class BorosHypeStrategy(
         hl_actual = inv.hl_perp_margin + inv.hl_spot_usdc
         boros_actual = inv.boros_committed_collateral_usd
         idle_actual = inv.usdc_arb_idle + inv.usdt_arb_idle
+        boros_target = self.hedge_cfg.boros_pct * total
+        if total >= self._planner_config.min_total_for_boros:
+            boros_target = max(
+                boros_target,
+                BOROS_MIN_DEPOSIT_HYPE * float(inv.hype_price_usd or 0.0),
+            )
 
         return AllocationStatus(
             spot_value=spot_actual,
@@ -669,7 +660,7 @@ class BorosHypeStrategy(
             boros_deviation=(boros_actual / total) - self.hedge_cfg.boros_pct,
             spot_needed_usd=max(0, (self.hedge_cfg.spot_pct * total) - spot_actual),
             hl_needed_usd=max(0, (self.hedge_cfg.hyperliquid_pct * total) - hl_actual),
-            boros_needed_usd=max(0, (self.hedge_cfg.boros_pct * total) - boros_actual),
+            boros_needed_usd=max(0, boros_target - boros_actual),
         )
 
     # ─────────────────────────────────────────────────────────────────────────
@@ -707,24 +698,36 @@ class BorosHypeStrategy(
         if inv.total_value < self._planner_config.min_total_for_boros:
             return True, "Below Boros minimum - skipping coverage check"
 
-        spot_usd = inv.total_hype_exposure * inv.hype_price_usd
-        if spot_usd < 10:
+        spot_hype = float(inv.total_hype_exposure or 0.0)
+        if spot_hype * float(inv.hype_price_usd or 0.0) < 10:
             return True, "Negligible spot exposure"
 
-        target_position = spot_usd * self._planner_config.boros_coverage_target
-        current_position = inv.boros_position_size
+        token_id = int(
+            self._planner_runtime.current_boros_token_id or BOROS_HYPE_TOKEN_ID
+        )
+        current_position_yu = float(inv.boros_position_size or 0.0)
 
-        if target_position < 10:
+        if token_id == BOROS_HYPE_TOKEN_ID:
+            target_position_yu = spot_hype * self._planner_config.boros_coverage_target
+            diff_yu = abs(current_position_yu - target_position_yu)
+            diff_usd = diff_yu * float(inv.hype_price_usd or 0.0)
+            target_usd = target_position_yu * float(inv.hype_price_usd or 0.0)
+        else:
+            spot_usd = spot_hype * float(inv.hype_price_usd or 0.0)
+            target_position_yu = (
+                spot_usd * self._planner_config.boros_coverage_target
+            )  # 1 YU = $1
+            diff_yu = abs(current_position_yu - target_position_yu)
+            diff_usd = diff_yu
+            target_usd = target_position_yu
+
+        if target_usd < 10:
             return True, "Target Boros position too small"
 
         # Use resize threshold as hysteresis band
-        diff = abs(current_position - target_position)
-        ok = diff <= self._planner_config.boros_resize_min_excess_usd
+        ok = diff_usd <= self._planner_config.boros_resize_min_excess_usd
 
-        return ok, (
-            f"diff=${diff:.2f} "
-            f"(current=${current_position:.0f}, target=${target_position:.0f})"
-        )
+        return ok, f"diff≈${diff_usd:.2f} (current={current_position_yu:.4f} YU)"
 
     # ─────────────────────────────────────────────────────────────────────────
     # Step Handlers
@@ -912,29 +915,47 @@ class BorosHypeStrategy(
             ok_boros, boros_msg = self._boros_coverage_ok(inv, self._opa_boros_quotes)
             if not ok_boros:
                 logger.info(f"[SAFETY] Boros coverage drift: {boros_msg}")
-                # Attempt fix; if Boros cannot be brought back into a sane state, melt down.
-                spot_usd = inv.total_hype_exposure * inv.hype_price_usd
-                target_usd = spot_usd * self._planner_config.boros_coverage_target
-
-                if self._planner_runtime.current_boros_market_id:
-                    ok, msg = await self._ensure_boros_position(
-                        {
-                            "market_id": self._planner_runtime.current_boros_market_id,
-                            "target_size_usd": target_usd,
-                        },
-                        inv,
+                depositable_collateral_hype = float(
+                    inv.boros_collateral_hype or 0.0
+                ) + float(inv.hype_oft_arb_balance or 0.0)
+                if depositable_collateral_hype < BOROS_MIN_DEPOSIT_HYPE:
+                    # Collateral isn't ready yet (or still in-flight via OFT); don't fail-safe.
+                    logger.info(
+                        "[SAFETY] Skipping Boros coverage fix: collateral not funded yet "
+                        f"({depositable_collateral_hype:.6f} HYPE)"
+                    )
+                else:
+                    # Attempt fix (best effort). If it fails, we log and keep running.
+                    token_id = int(
+                        self._planner_runtime.current_boros_token_id
+                        or BOROS_HYPE_TOKEN_ID
                     )
-                    if ok:
-                        safety_messages.append(
-                            f"Boros coverage adjusted to ${target_usd:.0f}"
+                    if token_id == BOROS_HYPE_TOKEN_ID:
+                        target_yu = (
+                            float(inv.total_hype_exposure or 0.0)
+                            * self._planner_config.boros_coverage_target
                         )
                     else:
-                        if not self.simulation:
-                            ok_fs, msg_fs = await self._failsafe_liquidate_all(
-                                f"Failed to restore Boros coverage: {boros_msg} | err={msg}"
+                        target_yu = (
+                            float(inv.total_hype_exposure or 0.0)
+                            * float(inv.hype_price_usd or 0.0)
+                            * self._planner_config.boros_coverage_target
+                        )
+
+                    if self._planner_runtime.current_boros_market_id:
+                        ok, msg = await self._ensure_boros_position(
+                            {
+                                "market_id": self._planner_runtime.current_boros_market_id,
+                                "target_size_yu": target_yu,
+                            },
+                            inv,
+                        )
+                        if ok:
+                            safety_messages.append(
+                                f"Boros coverage adjusted to {target_yu:.4f} YU"
                             )
-                            return ok_fs, msg_fs, rotated
-                        logger.warning(f"[SAFETY] Boros coverage fix failed: {msg}")
+                        else:
+                            logger.warning(f"[SAFETY] Boros coverage fix failed: {msg}")
 
             # Append safety messages to result
             if safety_messages:

wayfinder_paths/strategies/boros_hype_strategy/test_planner_golden.py

@@ -219,6 +219,8 @@ def test_build_plan_sizes_hedge_and_boros_position():
         total_value=total,
         spot_value_usd=600.0,
         hl_perp_margin=350.0,
+        hl_withdrawable_usd=350.0,
+        boros_collateral_hype=50.0 / 24.0,
         boros_collateral_usd=50.0,
         boros_committed_collateral_usd=50.0,
         usdc_arb_idle=0.0,
@@ -266,7 +268,7 @@ def test_build_plan_sizes_hedge_and_boros_position():
 
     boros_step = plan.steps[1]
     assert boros_step.params["market_id"] == BOROS_HYPE_MARKET_ID
-    assert abs(boros_step.params["target_size_usd"] - 240.0) < 1e-9
+    assert abs(boros_step.params["target_size_yu"] - 10.0) < 1e-9
 
     # Market selection should persist in runtime (hysteresis)
     assert runtime.current_boros_market_id == BOROS_HYPE_MARKET_ID

wayfinder_paths/strategies/boros_hype_strategy/test_strategy.py

@@ -41,8 +41,6 @@ def strategy():
 
     s = BorosHypeStrategy(
         config=mock_config,
-        main_wallet=mock_config["main_wallet"],
-        strategy_wallet=mock_config["strategy_wallet"],
         simulation=True,
     )
 

wayfinder_paths/strategies/boros_hype_strategy/types.py

@@ -310,7 +310,10 @@ class DesiredState:
 
     # Target positions
     target_hype_short_size: float
-    target_boros_position_usd: float
+    # Boros order sizing is in YU. YU units depend on collateral:
+    # - HYPE collateral: 1 YU = 1 HYPE
+    # - USDT collateral: 1 YU = 1 USDT (≈$1)
+    target_boros_position_yu: float
 
     # Selected Boros market
     boros_market_id: int | None = None

wayfinder_paths/strategies/hyperlend_stable_yield_strategy/strategy.py

@@ -193,13 +193,11 @@ class HyperlendStableYieldStrategy(Strategy):
         *,
         main_wallet: dict[str, Any] | None = None,
         strategy_wallet: dict[str, Any] | None = None,
-        api_key: str | None = None,
         main_wallet_signing_callback: Callable[[dict], Awaitable[str]] | None = None,
         strategy_wallet_signing_callback: Callable[[dict], Awaitable[str]]
         | None = None,
     ):
         super().__init__(
-            api_key=api_key,
             main_wallet_signing_callback=main_wallet_signing_callback,
             strategy_wallet_signing_callback=strategy_wallet_signing_callback,
         )

wayfinder_paths/strategies/hyperlend_stable_yield_strategy/test_strategy.py

@@ -21,8 +21,6 @@ def strategy():
 
     s = HyperlendStableYieldStrategy(
         config=mock_config,
-        main_wallet=mock_config["main_wallet"],
-        strategy_wallet=mock_config["strategy_wallet"],
     )
 
     if hasattr(s, "balance_adapter") and s.balance_adapter:

wayfinder_paths/strategies/moonwell_wsteth_loop_strategy/strategy.py

@@ -178,13 +178,11 @@ class MoonwellWstethLoopStrategy(Strategy):
         *,
         main_wallet: dict | None = None,
         strategy_wallet: dict | None = None,
-        api_key: str | None = None,
         main_wallet_signing_callback: Callable[[dict], Awaitable[str]] | None = None,
         strategy_wallet_signing_callback: Callable[[dict], Awaitable[str]]
         | None = None,
     ):
         super().__init__(
-            api_key=api_key,
             main_wallet_signing_callback=main_wallet_signing_callback,
             strategy_wallet_signing_callback=strategy_wallet_signing_callback,
         )

wayfinder_paths/strategies/moonwell_wsteth_loop_strategy/test_strategy.py

@@ -34,8 +34,6 @@ def strategy():
     ):
         s = MoonwellWstethLoopStrategy(
             config=mock_config,
-            main_wallet=mock_config["main_wallet"],
-            strategy_wallet=mock_config["strategy_wallet"],
         )
         # Manually set attributes that would be set in __init__
         s.config = mock_config

wayfinder_paths/strategies/stablecoin_yield_strategy/strategy.py

@@ -151,13 +151,11 @@ class StablecoinYieldStrategy(Strategy):
         *,
         main_wallet: dict[str, Any] | None = None,
         strategy_wallet: dict[str, Any] | None = None,
-        api_key: str | None = None,
         main_wallet_signing_callback: Callable[[dict], Awaitable[str]] | None = None,
         strategy_wallet_signing_callback: Callable[[dict], Awaitable[str]]
         | None = None,
     ):
         super().__init__(
-            api_key=api_key,
             main_wallet_signing_callback=main_wallet_signing_callback,
             strategy_wallet_signing_callback=strategy_wallet_signing_callback,
         )

wayfinder_paths/strategies/stablecoin_yield_strategy/test_strategy.py

@@ -23,8 +23,6 @@ def strategy():
 
     s = StablecoinYieldStrategy(
         config=mock_config,
-        main_wallet=mock_config["main_wallet"],
-        strategy_wallet=mock_config["strategy_wallet"],
     )
 
     if hasattr(s, "balance_adapter") and s.balance_adapter:

wayfinder_paths/tests/test_mcp_quote_swap.py

@@ -36,8 +36,8 @@ async def test_quote_swap_returns_compact_best_quote_by_default():
 
     class FakeBRAPClient:
         async def get_quote(self, **kwargs):  # noqa: ANN003
-            assert kwargs["from_chain_id"] == 42161
-            assert kwargs["to_chain_id"] == 42161
+            assert kwargs["from_chain"] == 42161
+            assert kwargs["to_chain"] == 42161
             assert kwargs["slippage"] == pytest.approx(0.005)
 
             calldata = "0x" + ("ab" * 4096)
@@ -46,7 +46,7 @@ async def test_quote_swap_returns_compact_best_quote_by_default():
                     "quote_count": 3,
                     "best_quote": {
                         "provider": "brap_best",
-                        "input_amount": kwargs["amount1"],
+                        "input_amount": kwargs["from_amount"],
                         "output_amount": "1234567",
                         "input_amount_usd": 5.0,
                         "output_amount_usd": 4.99,

{wayfinder_paths-0.1.25.dist-info → wayfinder_paths-0.1.27.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: wayfinder-paths
-Version: 0.1.25
+Version: 0.1.27
 Summary: Wayfinder Path: strategies and adapters
 Author: Wayfinder
 Author-email: dev@wayfinder.ai