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

wayfinder_paths/strategies/basis_trading_strategy/test_strategy.py

@@ -6,6 +6,10 @@ import pytest
 
 from wayfinder_paths.adapters.ledger_adapter.adapter import LedgerAdapter
 from wayfinder_paths.core.clients.LedgerClient import LedgerClient
+from wayfinder_paths.strategies.basis_trading_strategy.strategy import (
+    BasisPosition,
+    BasisTradingStrategy,
+)
 from wayfinder_paths.tests.test_utils import load_strategy_examples
 
 
@@ -122,6 +126,9 @@ class TestBasisTradingStrategy:
         mock.get_spot_user_state = AsyncMock(return_value=(True, {"balances": []}))
         mock.get_max_builder_fee = AsyncMock(return_value=(True, 0))
         mock.approve_builder_fee = AsyncMock(return_value=(True, {"status": "ok"}))
+        mock.ensure_builder_fee_approved = AsyncMock(
+            return_value=(True, "Builder fee approved: 0.030%")
+        )
         mock.update_leverage = AsyncMock(return_value=(True, {"status": "ok"}))
         mock.transfer_perp_to_spot = AsyncMock(return_value=(True, {"status": "ok"}))
         mock.transfer_spot_to_perp = AsyncMock(return_value=(True, {"status": "ok"}))
@@ -161,10 +168,6 @@ class TestBasisTradingStrategy:
                         "wayfinder_paths.strategies.basis_trading_strategy.strategy.LedgerAdapter",
                         return_value=ledger_adapter,
                     ):
-                        from wayfinder_paths.strategies.basis_trading_strategy.strategy import (
-                            BasisTradingStrategy,
-                        )
-
                         s = BasisTradingStrategy(
                             config={
                                 "main_wallet": {"address": "0x1234"},
@@ -306,15 +309,11 @@ class TestBasisTradingStrategy:
         assert snapshot["wallet_address"] == "0x5678"
         assert snapshot["portfolio_value"] == status["portfolio_value"]
 
-    def test_maintenance_rate(self):
-        from wayfinder_paths.strategies.basis_trading_strategy.strategy import (
-            BasisTradingStrategy,
-        )
-
-        rate = BasisTradingStrategy.maintenance_rate_from_max_leverage(50)
+    def test_maintenance_rate(self, strategy):
+        rate = strategy.maintenance_rate_from_max_leverage(50)
         assert rate == 0.01
 
-        rate = BasisTradingStrategy.maintenance_rate_from_max_leverage(10)
+        rate = strategy.maintenance_rate_from_max_leverage(10)
         assert rate == 0.05
 
     def test_rolling_min_sum(self, strategy):
@@ -403,10 +402,6 @@ class TestBasisTradingStrategy:
     async def test_scale_up_position_below_minimum(
         self, strategy, mock_hyperliquid_adapter
     ):
-        from wayfinder_paths.strategies.basis_trading_strategy.strategy import (
-            BasisPosition,
-        )
-
         strategy.current_position = BasisPosition(
             coin="ETH",
             spot_asset_id=10000,
@@ -429,10 +424,6 @@ class TestBasisTradingStrategy:
     async def test_update_with_idle_capital_scales_up(
         self, strategy, mock_hyperliquid_adapter
     ):
-        from wayfinder_paths.strategies.basis_trading_strategy.strategy import (
-            BasisPosition,
-        )
-
         strategy.deposit_amount = 100.0
         strategy.current_position = BasisPosition(
             coin="ETH",
@@ -543,10 +534,6 @@ class TestBasisTradingStrategy:
                         "wayfinder_paths.strategies.basis_trading_strategy.strategy.LedgerAdapter",
                         return_value=ledger_adapter,
                     ):
-                        from wayfinder_paths.strategies.basis_trading_strategy.strategy import (
-                            BasisTradingStrategy,
-                        )
-
                         s = BasisTradingStrategy(
                             config={
                                 "main_wallet": {"address": "0x1234"},
@@ -556,22 +543,20 @@ class TestBasisTradingStrategy:
                         s.hyperliquid_adapter = mock_hyperliquid_adapter
                         s.ledger_adapter = ledger_adapter
 
-                        # Mock get_max_builder_fee returning sufficient approval
-                        mock_hyperliquid_adapter.get_max_builder_fee = AsyncMock(
-                            return_value=(
-                                True,
-                                30,
+                        # Mock ensure_builder_fee_approved returning already approved
+                        mock_hyperliquid_adapter.ensure_builder_fee_approved = (
+                            AsyncMock(
+                                return_value=(
+                                    True,
+                                    "Builder fee already approved (30 >= 30)",
+                                )
                             )
                         )
-                        mock_hyperliquid_adapter.approve_builder_fee = AsyncMock(
-                            return_value=(True, {"status": "ok"})
-                        )
 
                         success, msg = await s.ensure_builder_fee_approved()
                         assert success
                         assert "already approved" in msg.lower()
-                        # Should not have called approve_builder_fee
-                        mock_hyperliquid_adapter.approve_builder_fee.assert_not_called()
+                        mock_hyperliquid_adapter.ensure_builder_fee_approved.assert_called_once()
 
     @pytest.mark.asyncio
     async def test_ensure_builder_fee_approved_needs_approval(
@@ -591,10 +576,6 @@ class TestBasisTradingStrategy:
                         "wayfinder_paths.strategies.basis_trading_strategy.strategy.LedgerAdapter",
                         return_value=ledger_adapter,
                     ):
-                        from wayfinder_paths.strategies.basis_trading_strategy.strategy import (
-                            BasisTradingStrategy,
-                        )
-
                         s = BasisTradingStrategy(
                             config={
                                 "main_wallet": {"address": "0x1234"},
@@ -604,19 +585,17 @@ class TestBasisTradingStrategy:
                         s.hyperliquid_adapter = mock_hyperliquid_adapter
                         s.ledger_adapter = ledger_adapter
 
-                        # Mock get_max_builder_fee returning insufficient approval
-                        mock_hyperliquid_adapter.get_max_builder_fee = AsyncMock(
-                            return_value=(True, 0)
-                        )
-                        mock_hyperliquid_adapter.approve_builder_fee = AsyncMock(
-                            return_value=(True, {"status": "ok"})
+                        # Mock ensure_builder_fee_approved returning newly approved
+                        mock_hyperliquid_adapter.ensure_builder_fee_approved = (
+                            AsyncMock(
+                                return_value=(True, "Builder fee approved: 0.030%")
+                            )
                         )
 
                         success, msg = await s.ensure_builder_fee_approved()
                         assert success
                         assert "approved" in msg.lower()
-                        # Should have called approve_builder_fee
-                        mock_hyperliquid_adapter.approve_builder_fee.assert_called_once()
+                        mock_hyperliquid_adapter.ensure_builder_fee_approved.assert_called_once()
 
     @pytest.mark.asyncio
     async def test_portfolio_value_includes_spot_holdings(
@@ -792,10 +771,6 @@ class TestBasisTradingStrategy:
     async def test_update_near_liquidation_closes_and_redeploys(
         self, strategy, mock_hyperliquid_adapter
     ):
-        from wayfinder_paths.strategies.basis_trading_strategy.strategy import (
-            BasisPosition,
-        )
-
         strategy.deposit_amount = 100.0
         strategy.current_position = BasisPosition(
             coin="HYPE",
@@ -885,10 +860,6 @@ class TestBasisTradingStrategy:
                         "wayfinder_paths.strategies.basis_trading_strategy.strategy.LedgerAdapter",
                         return_value=ledger_adapter,
                     ):
-                        from wayfinder_paths.strategies.basis_trading_strategy.strategy import (
-                            BasisTradingStrategy,
-                        )
-
                         s = BasisTradingStrategy(
                             config={
                                 "main_wallet": {"address": "0x1234"},

wayfinder_paths/strategies/boros_hype_strategy/__init__.py

@@ -0,0 +1,3 @@
+from .strategy import BorosHypeStrategy
+
+__all__ = ["BorosHypeStrategy"]

wayfinder_paths/strategies/boros_hype_strategy/boros_ops_mixin.py

@@ -0,0 +1,450 @@
+"""
+Boros venue operations for BorosHypeStrategy.
+
+Kept as a mixin so the main strategy file stays readable without changing behavior.
+"""
+
+from __future__ import annotations
+
+import asyncio
+from datetime import datetime
+from typing import Any
+
+from loguru import logger
+from web3 import AsyncWeb3
+
+from wayfinder_paths.core.utils.transaction import encode_call, send_transaction
+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,
+    HYPE_OFT_ABI,
+    HYPE_OFT_ADDRESS,
+    HYPEREVM_CHAIN_ID,
+    LZ_EID_ARBITRUM,
+    MIN_HYPE_GAS,
+    USDC_ARB,
+    USDT_ARB,
+)
+from .types import Inventory
+
+
+def _pad_address_bytes32(address: str) -> bytes:
+    checksum = AsyncWeb3.to_checksum_address(address)
+    return bytes.fromhex(checksum[2:]).rjust(32, b"\x00")
+
+
+class BorosHypeBorosOpsMixin:
+    async def _fund_boros(
+        self, params: dict[str, Any], inventory: Inventory
+    ) -> tuple[bool, str]:
+        """Fund Boros using native HYPE collateral.
+
+        Flow:
+        - If we already have Arbitrum OFT HYPE, deposit it to Boros cross margin.
+        - Otherwise, bridge native HYPE from HyperEVM -> Arbitrum via LayerZero OFT.
+        """
+
+        amount_usd = float(params.get("amount_usd") or 0.0)
+        market_id = int(
+            params.get("market_id")
+            or self._planner_runtime.current_boros_market_id
+            or BOROS_HYPE_MARKET_ID
+        )
+        token_id = int(
+            params.get("token_id")
+            or self._planner_runtime.current_boros_token_id
+            or BOROS_HYPE_TOKEN_ID
+        )
+
+        collateral_address = str(
+            params.get("collateral_address")
+            or self._planner_runtime.current_boros_collateral_address
+            or ""
+        ).strip()
+        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 self.simulation:
+            return True, f"[SIMULATION] Funded Boros with ~${amount_usd:.2f} HYPE"
+
+        strategy_wallet = self._config.get("strategy_wallet", {})
+        wallet_address = strategy_wallet.get("address")
+        if not wallet_address:
+            return False, "No strategy wallet address configured"
+
+        if not self._sign_callback:
+            return False, "No signing callback configured"
+
+        if not self.boros_adapter:
+            return False, "Boros adapter not configured"
+
+        hype_price = float(inventory.hype_price_usd or 0.0)
+        if hype_price <= 0:
+            return False, f"Invalid HYPE price (${hype_price:.6f})"
+
+        target_hype = float(amount_usd) / hype_price
+        target_wei = int(target_hype * 1e18)
+
+        # 1) If we have OFT HYPE on Arbitrum, deposit it first (idempotent; avoids double-bridging).
+        available_oft_hype = float(inventory.hype_oft_arb_balance or 0.0)
+        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})"
+
+            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"
+            )
+            return True, (
+                f"Funded Boros with {deposit_hype:.6f} HYPE (≈${deposit_usd:.2f}) from Arbitrum OFT balance"
+            )
+
+        # 2) Bridge native HYPE from HyperEVM to Arbitrum using the OFT contract.
+        hype_balance = float(inventory.hype_hyperevm_balance or 0.0)
+        if hype_balance <= MIN_HYPE_GAS + 0.0005:
+            return (
+                False,
+                f"Insufficient HyperEVM HYPE to bridge (balance={hype_balance:.6f}, min_gas={MIN_HYPE_GAS:.6f})",
+            )
+
+        reserve_wei = int(MIN_HYPE_GAS * 1e18)
+        balance_wei = int(hype_balance * 1e18)
+        max_value_wei = max(0, balance_wei - reserve_wei)
+        if max_value_wei <= 0:
+            return False, "Insufficient HyperEVM HYPE to bridge after reserving gas"
+
+        bridge_amount_wei = min(target_wei, max_value_wei)
+        if bridge_amount_wei <= 0:
+            return True, "Boros funding: nothing to bridge"
+
+        to_bytes32 = _pad_address_bytes32(wallet_address)
+
+        async with web3_from_chain_id(HYPEREVM_CHAIN_ID) as w3:
+            contract = w3.eth.contract(
+                address=w3.to_checksum_address(HYPE_OFT_ADDRESS),
+                abi=HYPE_OFT_ABI,
+            )
+
+            # Quote fee, then clamp amount to fit balance (amount + fee) while
+            # still leaving MIN_HYPE_GAS behind for future gas.
+            send_params = (
+                int(LZ_EID_ARBITRUM),
+                to_bytes32,
+                int(bridge_amount_wei),
+                0,
+                b"",
+                b"",
+                b"",
+            )
+            fee = await contract.functions.quoteSend(send_params, False).call()
+            native_fee = int(fee[0])
+            lz_token_fee = int(fee[1])
+
+            max_send_amount_wei = max(0, max_value_wei - native_fee)
+            if bridge_amount_wei > max_send_amount_wei:
+                bridge_amount_wei = max_send_amount_wei
+                if bridge_amount_wei <= 0:
+                    return False, "Insufficient HyperEVM HYPE to cover OFT bridge fee"
+
+                send_params = (
+                    int(LZ_EID_ARBITRUM),
+                    to_bytes32,
+                    int(bridge_amount_wei),
+                    0,
+                    b"",
+                    b"",
+                    b"",
+                )
+                fee = await contract.functions.quoteSend(send_params, False).call()
+                native_fee = int(fee[0])
+                lz_token_fee = int(fee[1])
+
+            total_value_wei = int(bridge_amount_wei) + int(native_fee)
+            if total_value_wei > max_value_wei:
+                return False, "Insufficient HyperEVM HYPE to bridge after fee quote"
+
+        tx = await encode_call(
+            target=HYPE_OFT_ADDRESS,
+            abi=HYPE_OFT_ABI,
+            fn_name="send",
+            args=[
+                send_params,
+                (int(native_fee), int(lz_token_fee)),
+                AsyncWeb3.to_checksum_address(wallet_address),
+            ],
+            from_address=wallet_address,
+            chain_id=HYPEREVM_CHAIN_ID,
+            value=total_value_wei,
+        )
+
+        tx_hash = await send_transaction(tx, self._sign_callback, wait_for_receipt=True)
+
+        bridged_hype = float(bridge_amount_wei) / 1e18
+        bridged_usd = bridged_hype * hype_price
+
+        # Track in-flight amount so planner doesn't double-fund while the bridge settles.
+        self._planner_runtime.in_flight_boros_oft_hype = bridged_hype
+        self._planner_runtime.in_flight_boros_oft_hype_balance_before = float(
+            inventory.hype_oft_arb_balance or 0.0
+        )
+        self._planner_runtime.in_flight_boros_oft_hype_started_at = datetime.utcnow()
+
+        logger.info(
+            f"Initiated OFT bridge HyperEVM->Arbitrum: {bridged_hype:.6f} HYPE (≈${bridged_usd:.2f}), tx={tx_hash}"
+        )
+
+        return True, (
+            f"Bridging {bridged_hype:.6f} HYPE (≈${bridged_usd:.2f}) HyperEVM→Arbitrum via OFT; "
+            f"tx={tx_hash} (LayerZero: https://layerzeroscan.com/tx/{tx_hash}). "
+            "Once bridged HYPE lands on Arbitrum, the next tick will deposit it to Boros."
+        )
+
+    async def _ensure_boros_position(
+        self, params: dict[str, Any], inventory: Inventory
+    ) -> tuple[bool, str]:
+        # If Boros operations fail unexpectedly, triggers fail-safe liquidation.
+        market_id = int(
+            params.get("market_id")
+            or self._planner_runtime.current_boros_market_id
+            or BOROS_HYPE_MARKET_ID
+        )
+        token_id = int(
+            params.get("token_id")
+            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)
+
+        if inventory.boros_pending_withdrawal_usd > 0:
+            return True, (
+                f"Boros withdrawal pending (~${inventory.boros_pending_withdrawal_usd:.2f}). "
+                "Skipping Boros rate position actions until it settles."
+            )
+
+        if not self.boros_adapter or not market_id:
+            return False, "Boros adapter not configured or no market selected"
+
+        if self.simulation:
+            return (
+                True,
+                f"[SIMULATION] Boros position at market {market_id} set to ${target_size_usd:.0f}",
+            )
+
+        try:
+            return await self._ensure_boros_position_impl(
+                market_id=market_id,
+                token_id=token_id,
+                target_size_usd=target_size_usd,
+                inventory=inventory,
+            )
+        except Exception as exc:
+            logger.error(
+                f"[BOROS_FAIL] Critical failure in Boros position management: {exc}"
+            )
+            # Trigger fail-safe liquidation
+            return await self._failsafe_liquidate_all(
+                f"Boros position management failed: {exc}"
+            )
+
+    async def _ensure_boros_position_impl(
+        self,
+        *,
+        market_id: int,
+        token_id: int,
+        target_size_usd: float,
+        inventory: Inventory,
+    ) -> tuple[bool, str]:
+        # 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:
+            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", [])
+                logger.debug(
+                    f"Boros position check: isolated={balances.get('isolated', 0):.6f}, "
+                    f"cross={balances.get('cross', 0):.6f}, "
+                    f"total={balances.get('total', 0):.6f}, "
+                    f"isolated_positions={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: {exc}")
+
+        # 1) Best-effort: if any OFT HYPE is sitting idle on Arbitrum, deposit it to cross margin.
+        if inventory.hype_oft_arb_balance > 0.0:
+            try:
+                deposit_hype = float(inventory.hype_oft_arb_balance or 0.0)
+                deposit_usd = deposit_hype * float(inventory.hype_price_usd or 0.0)
+                if deposit_usd >= 1.0:
+                    ok_dep, dep_res = await self.boros_adapter.deposit_to_cross_margin(
+                        collateral_address=HYPE_OFT_ADDRESS,
+                        amount_wei=int(deposit_hype * 1e18),
+                        token_id=int(token_id),
+                        market_id=int(market_id),
+                    )
+                    if ok_dep:
+                        logger.info(
+                            f"Deposited idle OFT HYPE to Boros: {deposit_hype:.6f} (≈${deposit_usd:.2f})"
+                        )
+                        await asyncio.sleep(2)
+                    else:
+                        logger.warning(
+                            f"Failed to deposit OFT HYPE to Boros: {dep_res}"
+                        )
+            except Exception as exc:  # noqa: BLE001
+                logger.warning(f"Failed to deposit OFT HYPE to Boros: {exc}")
+
+        # 2) Rollover: close positions in other markets (best effort).
+        try:
+            for mid in inventory.boros_position_market_ids or []:
+                try:
+                    mid_int = int(mid)
+                except (TypeError, ValueError):
+                    continue
+                if mid_int <= 0 or mid_int == int(market_id):
+                    continue
+                try:
+                    await self.boros_adapter.close_positions_market(
+                        mid_int, token_id=int(token_id)
+                    )
+                    await asyncio.sleep(2)
+                except Exception as exc:  # noqa: BLE001
+                    logger.warning(f"Failed to close Boros market {mid_int}: {exc}")
+        except Exception as exc:  # noqa: BLE001
+            logger.warning(f"Failed Boros rollover close: {exc}")
+
+        success, positions = await self.boros_adapter.get_active_positions(
+            market_id=int(market_id)
+        )
+        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))
+
+        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})"
+
+        size_yu_wei = int(abs(diff_usd) * 1e18)  # Boros YU wei
+
+        if diff_usd > 0:
+            # Open/increase SHORT side (receive fixed)
+            ok_open, open_res = await self.boros_adapter.place_rate_order(
+                market_id=int(market_id),
+                token_id=int(token_id),
+                size_yu_wei=size_yu_wei,
+                side="short",
+                tif="IOC",
+            )
+            if not ok_open:
+                return False, f"Failed to open Boros position: {open_res}"
+            return (
+                True,
+                f"Boros position increased by ${diff_usd:.0f} on market {market_id}",
+            )
+
+        # Close/decrease position
+        ok_close, close_res = await self.boros_adapter.close_positions_market(
+            market_id=int(market_id),
+            token_id=int(token_id),
+            size_yu_wei=size_yu_wei,
+        )
+        if not ok_close:
+            return False, f"Failed to close Boros position: {close_res}"
+
+        return (
+            True,
+            f"Boros position decreased by ${abs(diff_usd):.0f} on market {market_id}",
+        )
+
+    async def _complete_pending_withdrawal(
+        self, params: dict[str, Any], inventory: Inventory
+    ) -> tuple[bool, str]:
+        # Legacy helper used by some withdrawal flows: swap USDT->USDC on Arbitrum
+        usdt_idle = float(params.get("usdt_idle") or 0.0)
+
+        if self.simulation:
+            return (
+                True,
+                f"[SIMULATION] Completed pending withdrawal: ${usdt_idle:.2f} USDT → USDC",
+            )
+
+        if usdt_idle < 1.0:
+            return True, f"Withdrawal completion: no USDT to swap (${usdt_idle:.2f})"
+
+        if not self.balance_adapter:
+            return False, "Balance adapter not configured"
+        if not self.brap_adapter:
+            return False, "BRAP adapter not configured"
+
+        strategy_wallet = self._config.get("strategy_wallet", {})
+        address = strategy_wallet.get("address")
+        if not address:
+            return False, "No strategy wallet address configured"
+
+        ok_usdt, usdt_raw = await self.balance_adapter.get_vault_wallet_balance(
+            USDT_ARB
+        )
+        if not ok_usdt or usdt_raw <= 0:
+            return True, f"Withdrawal completion: no USDT to swap (${usdt_idle:.2f})"
+
+        ok_swap, swap_res = await self.brap_adapter.swap_from_token_ids(
+            from_token_id=USDT_ARB,
+            to_token_id=USDC_ARB,
+            from_address=address,
+            amount=str(int(usdt_raw)),
+            slippage=0.005,
+            strategy_name="boros_hype_strategy",
+        )
+        if not ok_swap:
+            return False, f"Withdrawal completion swap failed: {swap_res}"
+
+        ok_usdc, usdc_raw = await self.balance_adapter.get_vault_wallet_balance(
+            USDC_ARB
+        )
+        usdc_tokens = (float(usdc_raw) / 1e6) if ok_usdc and usdc_raw > 0 else 0.0
+
+        return True, (
+            f"Withdrawal completion: swapped ${usdt_idle:.2f} USDT→USDC "
+            f"(${usdc_tokens:.2f} USDC)"
+        )