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

wayfinder_paths/strategies/boros_hype_strategy/boros_ops_mixin.py

@@ -19,14 +19,20 @@ from wayfinder_paths.core.utils.web3 import web3_from_chain_id
 from .constants import (
     BOROS_HYPE_MARKET_ID,
     BOROS_HYPE_TOKEN_ID,
-    BOROS_MIN_DEPOSIT_USD,
+    BOROS_MIN_DEPOSIT_HYPE,
+    HYPE_NATIVE,
     HYPE_OFT_ABI,
     HYPE_OFT_ADDRESS,
     HYPEREVM_CHAIN_ID,
+    KHYPE_LST,
+    LOOPED_HYPE,
     LZ_EID_ARBITRUM,
     MIN_HYPE_GAS,
     USDC_ARB,
     USDT_ARB,
+    WHYPE,
+    WHYPE_ABI,
+    WHYPE_ADDRESS,
 )
 from .types import Inventory
 
@@ -67,8 +73,8 @@ class BorosHypeBorosOpsMixin:
         if not collateral_address:
             collateral_address = HYPE_OFT_ADDRESS
 
-        if amount_usd < BOROS_MIN_DEPOSIT_USD:
-            return True, f"Skipping small Boros funding (${amount_usd:.2f})"
+        if amount_usd < 1.0:
+            return True, f"Skipping tiny Boros funding (${amount_usd:.2f})"
 
         if self.simulation:
             return True, f"[SIMULATION] Funded Boros with ~${amount_usd:.2f} HYPE"
@@ -96,28 +102,156 @@ class BorosHypeBorosOpsMixin:
         if available_oft_hype > 0:
             deposit_hype = min(available_oft_hype, target_hype)
             deposit_usd = deposit_hype * hype_price
-            if deposit_usd < 1.0:
-                return True, f"Skipping tiny OFT HYPE deposit (${deposit_usd:.2f})"
+            if deposit_usd >= 1.0:
+                deposit_wei = int(deposit_hype * 1e18)
+                ok_dep, dep_res = await self.boros_adapter.deposit_to_cross_margin(
+                    collateral_address=collateral_address,
+                    amount_wei=deposit_wei,
+                    token_id=token_id,
+                    market_id=market_id,
+                )
+                if not ok_dep:
+                    return False, f"Boros deposit failed: {dep_res}"
 
-            deposit_wei = int(deposit_hype * 1e18)
-            ok_dep, dep_res = await self.boros_adapter.deposit_to_cross_margin(
-                collateral_address=collateral_address,
-                amount_wei=deposit_wei,
-                token_id=token_id,
-                market_id=market_id,
-            )
-            if not ok_dep:
-                return False, f"Boros deposit failed: {dep_res}"
+                logger.info(
+                    f"Deposited {deposit_hype:.6f} HYPE (≈${deposit_usd:.2f}) to Boros cross margin"
+                )
 
-            logger.info(
-                f"Deposited {deposit_hype:.6f} HYPE (≈${deposit_usd:.2f}) to Boros cross margin"
-            )
-            return True, (
-                f"Funded Boros with {deposit_hype:.6f} HYPE (≈${deposit_usd:.2f}) from Arbitrum OFT balance"
-            )
+                # If this fully satisfies the target, stop here.
+                if deposit_hype >= target_hype - 1e-9:
+                    return True, (
+                        f"Funded Boros with {deposit_hype:.6f} HYPE (≈${deposit_usd:.2f}) "
+                        "from Arbitrum OFT balance"
+                    )
+
+                # Otherwise, bridge the remainder.
+                target_hype = max(0.0, target_hype - deposit_hype)
+                target_wei = int(target_hype * 1e18)
+            else:
+                logger.info(
+                    f"Skipping tiny OFT HYPE deposit (${deposit_usd:.2f}); will top up via bridge"
+                )
 
         # 2) Bridge native HYPE from HyperEVM to Arbitrum using the OFT contract.
         hype_balance = float(inventory.hype_hyperevm_balance or 0.0)
+        whype_balance = float(inventory.whype_balance or 0.0)
+        fee_buffer_hype = 0.03  # conservative buffer for OFT native fee
+        desired_native_hype = float(MIN_HYPE_GAS) + float(target_hype) + fee_buffer_hype
+        if whype_balance > 0.0:
+            # On HyperEVM, HYPE can be split between native HYPE and WHYPE. The OFT
+            # bridge requires native HYPE (msg.value), so unwrap enough WHYPE to
+            # cover (amount + fee) while still leaving MIN_HYPE_GAS for future gas.
+            if hype_balance < desired_native_hype:
+                unwrap_hype = min(whype_balance, desired_native_hype - hype_balance)
+                unwrap_wei = int(unwrap_hype * 1e18)
+                if self.balance_adapter:
+                    (
+                        ok_whype,
+                        whype_raw,
+                    ) = await self.balance_adapter.get_vault_wallet_balance(WHYPE)
+                    if ok_whype and isinstance(whype_raw, int) and whype_raw > 0:
+                        unwrap_wei = min(int(unwrap_wei), int(whype_raw))
+                if unwrap_wei > 0:
+                    if not self._sign_callback:
+                        return False, "No signing callback configured"
+
+                    logger.info(
+                        f"Unwrapping {unwrap_hype:.6f} WHYPE → native HYPE to fund OFT bridge"
+                    )
+                    try:
+                        tx = await encode_call(
+                            target=WHYPE_ADDRESS,
+                            abi=WHYPE_ABI,
+                            fn_name="withdraw",
+                            args=[int(unwrap_wei)],
+                            from_address=wallet_address,
+                            chain_id=HYPEREVM_CHAIN_ID,
+                        )
+                        tx_hash = await send_transaction(
+                            tx, self._sign_callback, wait_for_receipt=True
+                        )
+                        logger.info(f"WHYPE unwrap tx={tx_hash}")
+                        await asyncio.sleep(2)
+                    except Exception as exc:  # noqa: BLE001
+                        logger.warning(f"WHYPE unwrap failed: {exc}")
+
+                    if self.balance_adapter:
+                        (
+                            ok_hype,
+                            hype_raw,
+                        ) = await self.balance_adapter.get_vault_wallet_balance(
+                            HYPE_NATIVE
+                        )
+                        if ok_hype and hype_raw:
+                            hype_balance = float(hype_raw) / 1e18
+
+        # If we still don't have enough native HYPE and there are LSTs on HyperEVM,
+        # sell a small amount back to native HYPE so Boros can be funded.
+        if (
+            hype_balance < desired_native_hype
+            and (inventory.khype_value_usd > 0 or inventory.looped_hype_value_usd > 0)
+            and self.brap_adapter
+        ):
+            needed_hype = max(0.0, desired_native_hype - hype_balance)
+            if needed_hype > 0.01:
+                if inventory.khype_value_usd > 0 and inventory.khype_to_hype_ratio > 0:
+                    max_hype_from_khype = float(inventory.khype_value_usd) / hype_price
+                    sell_hype = min(needed_hype, max_hype_from_khype)
+                    sell_khype = sell_hype / float(inventory.khype_to_hype_ratio)
+                    sell_khype_wei = int(sell_khype * 1e18)
+                    if sell_khype_wei > 0:
+                        logger.info(
+                            f"Selling {sell_khype:.6f} kHYPE → native HYPE to fund Boros"
+                        )
+                        ok_swap, res_swap = await self.brap_adapter.swap_from_token_ids(
+                            from_token_id=KHYPE_LST,
+                            to_token_id=HYPE_NATIVE,
+                            from_address=wallet_address,
+                            amount=str(int(sell_khype_wei)),
+                            slippage=0.01,
+                            strategy_name="boros_hype_strategy",
+                        )
+                        if ok_swap:
+                            needed_hype = max(0.0, needed_hype - sell_hype)
+                            await asyncio.sleep(2)
+                        else:
+                            logger.warning(f"Sell kHYPE→HYPE failed: {res_swap}")
+
+                if (
+                    needed_hype > 0.01
+                    and inventory.looped_hype_value_usd > 0
+                    and inventory.looped_hype_to_hype_ratio > 0
+                ):
+                    max_hype_from_lhype = (
+                        float(inventory.looped_hype_value_usd) / hype_price
+                    )
+                    sell_hype = min(needed_hype, max_hype_from_lhype)
+                    sell_lhype = sell_hype / float(inventory.looped_hype_to_hype_ratio)
+                    sell_lhype_wei = int(sell_lhype * 1e18)
+                    if sell_lhype_wei > 0:
+                        logger.info(
+                            f"Selling {sell_lhype:.6f} looped HYPE → native HYPE to fund Boros"
+                        )
+                        ok_swap, res_swap = await self.brap_adapter.swap_from_token_ids(
+                            from_token_id=LOOPED_HYPE,
+                            to_token_id=HYPE_NATIVE,
+                            from_address=wallet_address,
+                            amount=str(int(sell_lhype_wei)),
+                            slippage=0.01,
+                            strategy_name="boros_hype_strategy",
+                        )
+                        if ok_swap:
+                            await asyncio.sleep(2)
+                        else:
+                            logger.warning(f"Sell looped HYPE→HYPE failed: {res_swap}")
+
+                if self.balance_adapter:
+                    (
+                        ok_hype,
+                        hype_raw,
+                    ) = await self.balance_adapter.get_vault_wallet_balance(HYPE_NATIVE)
+                    if ok_hype and hype_raw:
+                        hype_balance = float(hype_raw) / 1e18
         if hype_balance <= MIN_HYPE_GAS + 0.0005:
             return (
                 False,
@@ -142,6 +276,16 @@ class BorosHypeBorosOpsMixin:
                 abi=HYPE_OFT_ABI,
             )
 
+            conversion_rate = int(
+                await contract.functions.decimalConversionRate().call()
+            )  # OFT sharedDecimals rounding
+            if conversion_rate > 0:
+                bridge_amount_wei = (
+                    bridge_amount_wei // conversion_rate
+                ) * conversion_rate
+            if bridge_amount_wei <= 0:
+                return True, "Boros funding: amount too small after OFT rounding"
+
             # Quote fee, then clamp amount to fit balance (amount + fee) while
             # still leaving MIN_HYPE_GAS behind for future gas.
             send_params = (
@@ -158,6 +302,10 @@ class BorosHypeBorosOpsMixin:
             lz_token_fee = int(fee[1])
 
             max_send_amount_wei = max(0, max_value_wei - native_fee)
+            if conversion_rate > 0:
+                max_send_amount_wei = (
+                    max_send_amount_wei // conversion_rate
+                ) * conversion_rate
             if bridge_amount_wei > max_send_amount_wei:
                 bridge_amount_wei = max_send_amount_wei
                 if bridge_amount_wei <= 0:
@@ -230,7 +378,7 @@ class BorosHypeBorosOpsMixin:
             or self._planner_runtime.current_boros_token_id
             or BOROS_HYPE_TOKEN_ID
         )
-        target_size_usd = float(params.get("target_size_usd") or 0.0)
+        target_size_yu = float(params.get("target_size_yu") or 0.0)
 
         if inventory.boros_pending_withdrawal_usd > 0:
             return True, (
@@ -244,14 +392,14 @@ class BorosHypeBorosOpsMixin:
         if self.simulation:
             return (
                 True,
-                f"[SIMULATION] Boros position at market {market_id} set to ${target_size_usd:.0f}",
+                f"[SIMULATION] Boros position at market {market_id} set to {target_size_yu:.4f} YU",
             )
 
         try:
             return await self._ensure_boros_position_impl(
                 market_id=market_id,
                 token_id=token_id,
-                target_size_usd=target_size_usd,
+                target_size_yu=target_size_yu,
                 inventory=inventory,
             )
         except Exception as exc:
@@ -268,9 +416,21 @@ class BorosHypeBorosOpsMixin:
         *,
         market_id: int,
         token_id: int,
-        target_size_usd: float,
+        target_size_yu: float,
         inventory: Inventory,
     ) -> tuple[bool, str]:
+        # Only try to manage the rate position once we have at least the minimum
+        # HYPE collateral funded on Boros (or sitting idle as OFT HYPE on Arbitrum).
+        depositable_hype = float(inventory.boros_collateral_hype or 0.0) + float(
+            inventory.hype_oft_arb_balance or 0.0
+        )
+        if depositable_hype < BOROS_MIN_DEPOSIT_HYPE:
+            return (
+                True,
+                "Skipping Boros position: collateral not funded yet "
+                f"({depositable_hype:.6f} HYPE)",
+            )
+
         # 0) Move any isolated collateral to cross margin (cleanup).
         # Boros markets expire, so we need to get the actual market ID from isolated positions.
         try:
@@ -331,6 +491,38 @@ class BorosHypeBorosOpsMixin:
             except Exception as exc:  # noqa: BLE001
                 logger.warning(f"Failed to deposit OFT HYPE to Boros: {exc}")
 
+        # Deposits can land as isolated cash for the given market_id; ensure we
+        # sweep isolated -> cross again before attempting to trade.
+        try:
+            ok_bal, balances = await self.boros_adapter.get_account_balances(
+                token_id=int(token_id)
+            )
+            if ok_bal and isinstance(balances, dict):
+                isolated_positions = balances.get("isolated_positions", [])
+                for iso_pos in isolated_positions:
+                    iso_market_id = iso_pos.get("market_id")
+                    iso_balance = float(iso_pos.get("balance", 0) or 0.0)
+                    if iso_market_id and iso_balance > 0.001:
+                        iso_wei = int(iso_balance * 1e18)  # Boros cash units
+                        logger.info(
+                            f"Moving {iso_balance:.6f} collateral from isolated market {iso_market_id} to cross"
+                        )
+                        ok_xfer, res_xfer = await self.boros_adapter.cash_transfer(
+                            market_id=int(iso_market_id),
+                            amount_wei=iso_wei,
+                            is_deposit=False,  # isolated -> cross
+                        )
+                        if ok_xfer:
+                            await asyncio.sleep(2)
+                        else:
+                            logger.warning(
+                                f"Failed Boros isolated->cross transfer for market {iso_market_id}: {res_xfer}"
+                            )
+        except Exception as exc:  # noqa: BLE001
+            logger.warning(
+                f"Failed Boros isolated->cross transfer after deposit: {exc}"
+            )
+
         # 2) Rollover: close positions in other markets (best effort).
         try:
             for mid in inventory.boros_position_market_ids or []:
@@ -356,18 +548,20 @@ class BorosHypeBorosOpsMixin:
         if not success:
             return False, "Failed to get Boros positions"
 
-        current_size_usd = 0.0
         if positions:
             pos = positions[0]
-            current_size_usd = abs(float(pos.get("size", 0) or 0.0))
+            current_size_yu = abs(float(pos.get("size", 0) or 0.0))
+        else:
+            current_size_yu = 0.0
 
-        diff_usd = float(target_size_usd) - float(current_size_usd)
-        if abs(diff_usd) < self._planner_config.boros_resize_min_excess_usd:
-            return True, f"Boros position already at target (${current_size_usd:.0f})"
+        diff_yu = float(target_size_yu) - float(current_size_yu)
+        diff_usd_equiv = abs(diff_yu) * float(inventory.hype_price_usd or 0.0)
+        if diff_usd_equiv < self._planner_config.boros_resize_min_excess_usd:
+            return True, f"Boros position already at target ({current_size_yu:.4f} YU)"
 
-        size_yu_wei = int(abs(diff_usd) * 1e18)  # Boros YU wei
+        size_yu_wei = int(abs(diff_yu) * 1e18)  # Boros YU wei
 
-        if diff_usd > 0:
+        if diff_yu > 0:
             # Open/increase SHORT side (receive fixed)
             ok_open, open_res = await self.boros_adapter.place_rate_order(
                 market_id=int(market_id),
@@ -380,7 +574,7 @@ class BorosHypeBorosOpsMixin:
                 return False, f"Failed to open Boros position: {open_res}"
             return (
                 True,
-                f"Boros position increased by ${diff_usd:.0f} on market {market_id}",
+                f"Boros position increased by {diff_yu:.4f} YU on market {market_id}",
             )
 
         # Close/decrease position
@@ -394,7 +588,7 @@ class BorosHypeBorosOpsMixin:
 
         return (
             True,
-            f"Boros position decreased by ${abs(diff_usd):.0f} on market {market_id}",
+            f"Boros position decreased by {abs(diff_yu):.4f} YU on market {market_id}",
         )
 
     async def _complete_pending_withdrawal(

wayfinder_paths/strategies/boros_hype_strategy/constants.py

@@ -94,7 +94,9 @@ HORIZON_DAYS = 7  # Planning horizon in days
 # entry path uses HYPE collateral (via the LayerZero OFT token on Arbitrum).
 BOROS_HYPE_MARKET_ID = 51  # HYPERLIQUID-HYPE-27FEB2026 (fallback)
 BOROS_HYPE_TOKEN_ID = 5  # HYPE collateral token ID on Boros (current)
-BOROS_MIN_DEPOSIT_USD = 10.50  # Minimum collateral value to bother funding
+# Boros requires a minimum cross-margin cash balance per token to place orders.
+# For the HYPE collateral token (tokenId=5) this is currently 0.4 HYPE (MarketHub.getCashFeeData()).
+BOROS_MIN_DEPOSIT_HYPE = 0.4
 BOROS_MIN_TENOR_DAYS = 3  # Roll to new market if < 3 days to expiry
 BOROS_ENABLE_MIN_TOTAL_USD = 80.0  # Skip Boros if capital below this
 
@@ -237,6 +239,20 @@ HYPE_OFT_ABI = [
         "stateMutability": "payable",
         "type": "function",
     },
+    {
+        "inputs": [],
+        "name": "sharedDecimals",
+        "outputs": [{"internalType": "uint8", "name": "", "type": "uint8"}],
+        "stateMutability": "view",
+        "type": "function",
+    },
+    {
+        "inputs": [],
+        "name": "decimalConversionRate",
+        "outputs": [{"internalType": "uint256", "name": "", "type": "uint256"}],
+        "stateMutability": "view",
+        "type": "function",
+    },
 ]
 
 # ─────────────────────────────────────────────────────────────────────────────

wayfinder_paths/strategies/boros_hype_strategy/hyperevm_ops_mixin.py

@@ -6,9 +6,22 @@ Kept as a mixin so the main strategy file stays readable without changing behavi
 
 from __future__ import annotations
 
+import asyncio
 from typing import Any
 
-from .constants import HYPE_NATIVE, KHYPE_LST, LOOPED_HYPE, MIN_HYPE_GAS
+from loguru import logger
+
+from wayfinder_paths.core.utils.transaction import encode_call, send_transaction
+
+from .constants import (
+    HYPE_NATIVE,
+    HYPEREVM_CHAIN_ID,
+    KHYPE_LST,
+    LOOPED_HYPE,
+    MIN_HYPE_GAS,
+    WHYPE_ABI,
+    WHYPE_ADDRESS,
+)
 from .types import Inventory
 
 
@@ -21,6 +34,36 @@ class BorosHypeHyperEvmOpsMixin:
         if need <= 0.0:
             return True, "HyperEVM gas already sufficient"
 
+        # If we have WHYPE on HyperEVM, unwrap a small amount to native HYPE for gas.
+        if float(inventory.whype_balance or 0.0) > 0.0:
+            strategy_wallet = self._config.get("strategy_wallet", {})
+            address = strategy_wallet.get("address")
+            if address and self._sign_callback:
+                unwrap_hype = min(
+                    float(inventory.whype_balance or 0.0), max(0.01, need + 0.002)
+                )
+                unwrap_wei = int(unwrap_hype * 1e18)
+                if unwrap_wei > 0:
+                    logger.info(
+                        f"Unwrapping {unwrap_hype:.6f} WHYPE → native HYPE for gas"
+                    )
+                    tx = await encode_call(
+                        target=WHYPE_ADDRESS,
+                        abi=WHYPE_ABI,
+                        fn_name="withdraw",
+                        args=[int(unwrap_wei)],
+                        from_address=address,
+                        chain_id=HYPEREVM_CHAIN_ID,
+                    )
+                    tx_hash = await send_transaction(
+                        tx, self._sign_callback, wait_for_receipt=True
+                    )
+                    await asyncio.sleep(2)
+                    return (
+                        True,
+                        f"Unwrapped {unwrap_hype:.6f} WHYPE for gas (tx={tx_hash})",
+                    )
+
         # Best-effort: if HYPE exists on HL spot, bridge it over.
         if inventory.hl_spot_hype > max(0.1, need + 0.001):
             return await self._transfer_hl_spot_to_hyperevm(

wayfinder_paths/strategies/boros_hype_strategy/planner.py

@@ -13,7 +13,13 @@ from datetime import datetime
 
 from wayfinder_paths.adapters.boros_adapter import BorosMarketQuote
 
-from .constants import BOROS_MIN_DEPOSIT_USD, BOROS_MIN_TENOR_DAYS, MIN_HYPE_GAS
+from .constants import (
+    BOROS_HYPE_TOKEN_ID,
+    BOROS_MIN_DEPOSIT_HYPE,
+    BOROS_MIN_TENOR_DAYS,
+    MAX_HL_LEVERAGE,
+    MIN_HYPE_GAS,
+)
 from .types import (
     AllocationStatus,
     DesiredState,
@@ -147,7 +153,7 @@ def build_plan(
                 target_hl_margin_usd=0,
                 target_boros_collateral_usd=0,
                 target_hype_short_size=0,
-                target_boros_position_usd=0,
+                target_boros_position_yu=0,
             ),
         )
         plan.messages.append(
@@ -165,7 +171,7 @@ def build_plan(
                 target_hl_margin_usd=0,
                 target_boros_collateral_usd=0,
                 target_hype_short_size=0,
-                target_boros_position_usd=0,
+                target_boros_position_yu=0,
             ),
         )
         plan.messages.append(
@@ -203,9 +209,12 @@ def build_plan(
     target_hl = total * hedge_cfg.hyperliquid_pct
 
     # Boros target: use MAX of percentage allocation and minimum deposit + buffer.
-    # We keep a small buffer so the USDC→USDT swap doesn't undershoot the Boros minimum.
+    # We keep a small buffer so rounding doesn't undershoot the Boros minimum.
     target_boros = (
-        max(hedge_cfg.boros_pct * total, BOROS_MIN_DEPOSIT_USD + 1.0)
+        max(
+            hedge_cfg.boros_pct * total,
+            (BOROS_MIN_DEPOSIT_HYPE + 0.01) * float(inv.hype_price_usd or 0.0),
+        )
         if boros_enabled
         else 0.0
     )
@@ -223,12 +232,19 @@ def build_plan(
     # Short target = current HYPE exposure (to hedge what we actually have)
     target_hype_short = inv.total_hype_exposure
 
-    # Boros coverage target = percentage of spot exposure
-    target_boros_position = (
-        target_hype_short * inv.hype_price_usd * config.boros_coverage_target
-        if boros_enabled and market_id
-        else 0.0
-    )
+    # Boros position sizing is in YU, but YU units depend on the collateral token:
+    # - HYPE collateral: 1 YU = 1 HYPE
+    # - USDT collateral: 1 YU = 1 USDT (≈$1)
+    # For HYPE collateral we size to HYPE exposure; for USDT we size to USD notional.
+    if boros_enabled and market_id:
+        if boros_token_id == BOROS_HYPE_TOKEN_ID:
+            target_boros_position_yu = target_hype_short * config.boros_coverage_target
+        else:
+            target_boros_position_yu = (
+                target_hype_short * inv.hype_price_usd * config.boros_coverage_target
+            )
+    else:
+        target_boros_position_yu = 0.0
 
     desired = DesiredState(
         mode=mode,
@@ -236,7 +252,7 @@ def build_plan(
         target_hl_margin_usd=target_hl,
         target_boros_collateral_usd=target_boros,
         target_hype_short_size=target_hype_short,
-        target_boros_position_usd=target_boros_position,
+        target_boros_position_yu=target_boros_position_yu,
         boros_market_id=market_id,
         boros_market_symbol=market_symbol,
         boros_tenor_days=tenor_days,
@@ -302,19 +318,18 @@ def build_plan(
             0.0, target_boros - float(inv.boros_committed_collateral_usd or 0.0)
         )
         if boros_shortfall >= config.min_usdt_action:
-            if boros_shortfall >= BOROS_MIN_DEPOSIT_USD:
-                plan.add_step(
-                    PlanOp.FUND_BOROS,
-                    priority=10,
-                    key=f"fund_boros_{boros_shortfall:.2f}",
-                    params={
-                        "amount_usd": float(boros_shortfall),
-                        "market_id": int(market_id) if market_id else None,
-                        "token_id": int(boros_token_id) if boros_token_id else None,
-                        "collateral_address": str(boros_collateral_address or ""),
-                    },
-                    reason=f"Funding Boros toward target (${target_boros:.2f}) via HYPE collateral",
-                )
+            plan.add_step(
+                PlanOp.FUND_BOROS,
+                priority=10,
+                key=f"fund_boros_{boros_shortfall:.2f}",
+                params={
+                    "amount_usd": float(boros_shortfall),
+                    "market_id": int(market_id) if market_id else None,
+                    "token_id": int(boros_token_id) if boros_token_id else None,
+                    "collateral_address": str(boros_collateral_address or ""),
+                },
+                reason=f"Funding Boros toward target (${target_boros:.2f}) via HYPE collateral",
+            )
 
     # Send USDC to Hyperliquid ONCE to cover both:
     # - HL margin allocation
@@ -403,6 +418,32 @@ def build_plan(
         target_hype_short * config.delta_neutral_rel_tol,
     )
 
+    # If we can't hedge to within tolerance due to margin constraints, trim spot first.
+    # (This avoids safety-triggered liquidation loops when HL free margin is too low.)
+    hedge_increase_needed = float(target_hype_short) - float(current_short)
+    if hedge_increase_needed > 0 and target_hype_short > 0.1:
+        hype_price = float(inv.hype_price_usd or 0.0)
+        free_margin = float(inv.hl_withdrawable_usd or 0.0)
+        max_increase_by_margin = (
+            (free_margin * MAX_HL_LEVERAGE) / hype_price if hype_price > 0 else 0.0
+        )
+        if hedge_increase_needed > max_increase_by_margin + tolerance:
+            trim_hype = hedge_increase_needed - (max_increase_by_margin + tolerance)
+            trim_usd = trim_hype * hype_price
+            if inv.spot_value_usd > 0:
+                trim_pct = min(0.50, trim_usd / float(inv.spot_value_usd))
+                if trim_pct > 0.02:
+                    plan.add_step(
+                        PlanOp.PARTIAL_TRIM_SPOT,
+                        priority=0,
+                        key="partial_trim_spot_for_margin",
+                        params={"trim_pct": float(trim_pct)},
+                        reason=(
+                            "Insufficient HL free margin to hedge within tolerance; "
+                            f"trimming spot by ~${trim_usd:.2f}"
+                        ),
+                    )
+
     if short_delta > tolerance and target_hype_short > 0.1:
         plan.add_step(
             PlanOp.ENSURE_HL_SHORT,
@@ -414,14 +455,28 @@ def build_plan(
 
     # Priority 30: Rate positions (Boros)
     if boros_enabled and market_id:
-        current_boros_size = inv.boros_position_size
-        size_diff = abs(target_boros_position - current_boros_size)
+        # Only try to manage rate positions once collateral is actually available.
+        # (In-flight OFT bridges are tracked separately; they can't be used yet.)
+        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:
+            plan.messages.append(
+                "Skipping Boros position: collateral not funded yet "
+                f"({depositable_collateral_hype:.6f} HYPE)"
+            )
+            plan.sort_steps()
+            return plan
+
+        current_boros_size_yu = float(inv.boros_position_size or 0.0)
+        size_diff_yu = abs(target_boros_position_yu - current_boros_size_yu)
+        size_diff_usd = size_diff_yu * float(inv.hype_price_usd or 0.0)
 
         # Trigger if:
         # 1. Position size needs adjustment (resize threshold met)
         # 2. There's isolated collateral that needs to move to cross (market expiry/rotation)
         # 3. There's cross collateral but no position (collateral sitting idle)
-        needs_position_resize = size_diff > config.boros_resize_min_excess_usd
+        needs_position_resize = size_diff_usd > config.boros_resize_min_excess_usd
         isolated_usd = float(inv.boros_idle_collateral_isolated or 0.0) * float(
             inv.hype_price_usd or 0.0
         )
@@ -429,10 +484,10 @@ def build_plan(
             inv.hype_price_usd or 0.0
         )
         has_stranded_isolated = isolated_usd > 0.5  # $0.50 threshold
-        has_idle_cross = cross_usd > 1.0 and current_boros_size < 1.0
+        has_idle_cross = cross_usd > 1.0 and current_boros_size_yu < 0.01
 
         if needs_position_resize or has_stranded_isolated or has_idle_cross:
-            reason = f"Adjusting Boros position to {target_boros_position:.0f} YU"
+            reason = f"Adjusting Boros position to {target_boros_position_yu:.4f} YU"
             if has_stranded_isolated and not needs_position_resize:
                 reason = (
                     "Moving "
@@ -448,10 +503,10 @@ def build_plan(
             plan.add_step(
                 PlanOp.ENSURE_BOROS_POSITION,
                 priority=20,  # Same as ENSURE_HL_SHORT so both execute before re-observe
-                key=f"ensure_boros_pos_{target_boros_position:.0f}",
+                key=f"ensure_boros_pos_{target_boros_position_yu:.4f}",
                 params={
                     "market_id": market_id,
-                    "target_size_usd": target_boros_position,
+                    "target_size_yu": target_boros_position_yu,
                 },
                 reason=reason,
             )