wayfinder-paths 0.1.14__py3-none-any.whl → 0.1.16__py3-none-any.whl

wayfinder_paths/strategies/basis_trading_strategy/test_strategy.py

@@ -143,7 +143,8 @@ class TestBasisTradingStrategy:
             return_value=(True, 100.0)  # (deposit_confirmed, final_balance)
         )
         mock.wait_for_withdrawal = AsyncMock(
-            return_value=(True, {"0x123456": 100.0})  # tx_hash -> amount (float)
+            # tx_hash -> amount (float)
+            return_value=(True, {"0x123456": 100.0})
         )
         return mock
 
@@ -170,68 +171,53 @@ class TestBasisTradingStrategy:
                         "wayfinder_paths.strategies.basis_trading_strategy.strategy.LedgerAdapter",
                         return_value=ledger_adapter,
                     ):
-                        with patch(
-                            "wayfinder_paths.strategies.basis_trading_strategy.strategy.WalletManager"
-                        ):
-                            from wayfinder_paths.strategies.basis_trading_strategy.strategy import (
-                                BasisTradingStrategy,
-                            )
-
-                            s = BasisTradingStrategy(
-                                config={
-                                    "main_wallet": {"address": "0x1234"},
-                                    "strategy_wallet": {"address": "0x5678"},
-                                },
-                            )
-                            s.hyperliquid_adapter = mock_hyperliquid_adapter
-                            s.ledger_adapter = ledger_adapter
-                            s.balance_adapter = MagicMock()
-                            s.balance_adapter.get_balance = AsyncMock(
-                                return_value=(True, 0)
-                            )
-                            s.balance_adapter.move_from_main_wallet_to_strategy_wallet = AsyncMock(
-                                return_value=(True, {})
-                            )
-                            s.balance_adapter.move_from_strategy_wallet_to_main_wallet = AsyncMock(
-                                return_value=(True, {})
-                            )
-                            s.balance_adapter.send_to_address = AsyncMock(
-                                return_value=(True, {"tx_hash": "0x123"})
-                            )
-                            # Mock internal dependencies to prevent MagicMock await errors
-                            # These are needed if the real method somehow gets called
-                            s.balance_adapter.token_client = AsyncMock()
-                            s.balance_adapter.token_client.get_token_details = (
-                                AsyncMock(
-                                    return_value={
-                                        "id": "usdc",
-                                        "address": "0x1234",
-                                        "decimals": 6,
-                                    }
-                                )
-                            )
-                            s.balance_adapter.token_transactions = AsyncMock()
-                            s.balance_adapter.token_transactions.build_send = AsyncMock(
-                                return_value=(True, {"transaction": "0xMOCK"})
-                            )
-                            s.balance_adapter.wallet_provider = AsyncMock()
-                            s.balance_adapter.wallet_provider.broadcast_transaction = (
-                                AsyncMock(
-                                    return_value=(True, {"transaction_hash": "0x123"})
-                                )
-                            )
-                            s.balance_adapter.token_adapter = AsyncMock()
-                            s.balance_adapter.token_adapter.get_token_price = AsyncMock(
-                                return_value=(True, {"current_price": 1.0})
-                            )
-                            # ledger_adapter is real, but ensure its methods are async-mockable
-                            s.balance_adapter.ledger_adapter = ledger_adapter
-                            # Also ensure the balance_adapter's _move_between_wallets won't call real methods
-                            # by making sure all its dependencies return AsyncMock
-                            s.balance_adapter._move_between_wallets = AsyncMock(
-                                return_value=(True, {"transaction_hash": "0x123"})
-                            )
-                            return s
+                        from wayfinder_paths.strategies.basis_trading_strategy.strategy import (
+                            BasisTradingStrategy,
+                        )
+
+                        s = BasisTradingStrategy(
+                            config={
+                                "main_wallet": {"address": "0x1234"},
+                                "strategy_wallet": {"address": "0x5678"},
+                            },
+                        )
+                        s.hyperliquid_adapter = mock_hyperliquid_adapter
+                        s.ledger_adapter = ledger_adapter
+                        s.balance_adapter = MagicMock()
+                        s.balance_adapter.get_balance = AsyncMock(
+                            return_value=(True, 0)
+                        )
+                        s.balance_adapter.move_from_main_wallet_to_strategy_wallet = (
+                            AsyncMock(return_value=(True, {}))
+                        )
+                        s.balance_adapter.move_from_strategy_wallet_to_main_wallet = (
+                            AsyncMock(return_value=(True, {}))
+                        )
+                        s.balance_adapter.send_to_address = AsyncMock(
+                            return_value=(True, {"tx_hash": "0x123"})
+                        )
+                        # Mock internal dependencies to prevent MagicMock await errors
+                        # These are needed if the real method somehow gets called
+                        s.balance_adapter.token_client = AsyncMock()
+                        s.balance_adapter.token_client.get_token_details = AsyncMock(
+                            return_value={
+                                "id": "usdc",
+                                "address": "0x1234",
+                                "decimals": 6,
+                            }
+                        )
+                        s.balance_adapter.token_adapter = AsyncMock()
+                        s.balance_adapter.token_adapter.get_token_price = AsyncMock(
+                            return_value=(True, {"current_price": 1.0})
+                        )
+                        # ledger_adapter is real, but ensure its methods are async-mockable
+                        s.balance_adapter.ledger_adapter = ledger_adapter
+                        # Also ensure the balance_adapter's _move_between_wallets won't call real methods
+                        # by making sure all its dependencies return AsyncMock
+                        s.balance_adapter._move_between_wallets = AsyncMock(
+                            return_value=(True, {"transaction_hash": "0x123"})
+                        )
+                        return s
 
     @pytest.mark.asyncio
     @pytest.mark.smoke
@@ -303,7 +289,7 @@ class TestBasisTradingStrategy:
 
         success, msg = await strategy.update()
         assert success is False
-        assert "No deposit" in msg
+        assert "No funds to manage" in msg
 
     @pytest.mark.asyncio
     async def test_withdraw_without_deposit(self, strategy):
@@ -461,7 +447,7 @@ class TestBasisTradingStrategy:
         # Try to scale with $5 (below $10 minimum notional)
         # With 2x leverage, order_usd = 5 * (2/3) = 3.33, below $10
         success, msg = await strategy._scale_up_position(5.0)
-        assert success is True  # Returns success=True but with message
+        assert success  # Returns success=True but with message
         assert "below minimum notional" in msg
 
     @pytest.mark.asyncio
@@ -563,7 +549,7 @@ class TestBasisTradingStrategy:
 
             # Should have called fill_pair_units to scale up
             assert mock_filler.fill_pair_units.called
-            assert success is True
+            assert success
 
     @pytest.mark.asyncio
     async def test_ensure_builder_fee_approved_already_approved(
@@ -584,38 +570,35 @@ class TestBasisTradingStrategy:
                         "wayfinder_paths.strategies.basis_trading_strategy.strategy.LedgerAdapter",
                         return_value=ledger_adapter,
                     ):
-                        with patch(
-                            "wayfinder_paths.strategies.basis_trading_strategy.strategy.WalletManager"
-                        ):
-                            from wayfinder_paths.strategies.basis_trading_strategy.strategy import (
-                                BasisTradingStrategy,
-                            )
-
-                            s = BasisTradingStrategy(
-                                config={
-                                    "main_wallet": {"address": "0x1234"},
-                                    "strategy_wallet": {"address": "0x5678"},
-                                },
-                            )
-                            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,
-                                )  # Already approved for 30 tenths bp
-                            )
-                            mock_hyperliquid_adapter.approve_builder_fee = AsyncMock(
-                                return_value=(True, {"status": "ok"})
-                            )
-
-                            success, msg = await s.ensure_builder_fee_approved()
-                            assert success is True
-                            assert "already approved" in msg.lower()
-                            # Should not have called approve_builder_fee
-                            mock_hyperliquid_adapter.approve_builder_fee.assert_not_called()
+                        from wayfinder_paths.strategies.basis_trading_strategy.strategy import (
+                            BasisTradingStrategy,
+                        )
+
+                        s = BasisTradingStrategy(
+                            config={
+                                "main_wallet": {"address": "0x1234"},
+                                "strategy_wallet": {"address": "0x5678"},
+                            },
+                        )
+                        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,
+                            )  # Already approved for 30 tenths bp
+                        )
+                        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()
 
     @pytest.mark.asyncio
     async def test_ensure_builder_fee_approved_needs_approval(
@@ -636,35 +619,32 @@ class TestBasisTradingStrategy:
                         "wayfinder_paths.strategies.basis_trading_strategy.strategy.LedgerAdapter",
                         return_value=ledger_adapter,
                     ):
-                        with patch(
-                            "wayfinder_paths.strategies.basis_trading_strategy.strategy.WalletManager"
-                        ):
-                            from wayfinder_paths.strategies.basis_trading_strategy.strategy import (
-                                BasisTradingStrategy,
-                            )
-
-                            s = BasisTradingStrategy(
-                                config={
-                                    "main_wallet": {"address": "0x1234"},
-                                    "strategy_wallet": {"address": "0x5678"},
-                                },
-                            )
-                            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)  # Not approved yet
-                            )
-                            mock_hyperliquid_adapter.approve_builder_fee = AsyncMock(
-                                return_value=(True, {"status": "ok"})
-                            )
-
-                            success, msg = await s.ensure_builder_fee_approved()
-                            assert success is True
-                            assert "approved" in msg.lower()
-                            # Should have called approve_builder_fee
-                            mock_hyperliquid_adapter.approve_builder_fee.assert_called_once()
+                        from wayfinder_paths.strategies.basis_trading_strategy.strategy import (
+                            BasisTradingStrategy,
+                        )
+
+                        s = BasisTradingStrategy(
+                            config={
+                                "main_wallet": {"address": "0x1234"},
+                                "strategy_wallet": {"address": "0x5678"},
+                            },
+                        )
+                        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)  # Not approved yet
+                        )
+                        mock_hyperliquid_adapter.approve_builder_fee = AsyncMock(
+                            return_value=(True, {"status": "ok"})
+                        )
+
+                        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()
 
     @pytest.mark.asyncio
     async def test_portfolio_value_includes_spot_holdings(
@@ -832,7 +812,7 @@ class TestBasisTradingStrategy:
             mock_filler_class.return_value = mock_filler
 
             success, _ = await strategy.update()
-            assert success is True
+            assert success
 
         # Target spot was $66.67, so we should transfer $33.33 spot->perp.
         mock_hyperliquid_adapter.transfer_spot_to_perp.assert_called_once()
@@ -907,7 +887,7 @@ class TestBasisTradingStrategy:
         strategy._find_and_open_position = AsyncMock(return_value=(True, "redeployed"))
 
         success, msg = await strategy.update()
-        assert success is True
+        assert success
         assert msg == "redeployed"
         strategy._close_position.assert_awaited_once()
         strategy._find_and_open_position.assert_awaited_once()
@@ -954,29 +934,26 @@ class TestBasisTradingStrategy:
                         "wayfinder_paths.strategies.basis_trading_strategy.strategy.LedgerAdapter",
                         return_value=ledger_adapter,
                     ):
-                        with patch(
-                            "wayfinder_paths.strategies.basis_trading_strategy.strategy.WalletManager"
-                        ):
-                            from wayfinder_paths.strategies.basis_trading_strategy.strategy import (
-                                BasisTradingStrategy,
-                            )
-
-                            s = BasisTradingStrategy(
-                                config={
-                                    "main_wallet": {"address": "0x1234"},
-                                    "strategy_wallet": {"address": "0x5678"},
-                                },
-                            )
-                            s.hyperliquid_adapter = mock_hyperliquid_adapter
-                            s.ledger_adapter = ledger_adapter
-
-                            # Mock get_strategy_net_deposit to return float (not dict)
-                            s.ledger_adapter.get_strategy_net_deposit = AsyncMock(
-                                return_value=(True, 2500.0)
-                            )
-
-                            # Run setup - should not raise AttributeError
-                            await s.setup()
-
-                            # Verify deposit_amount was set from the float
-                            assert s.deposit_amount == 2500.0
+                        from wayfinder_paths.strategies.basis_trading_strategy.strategy import (
+                            BasisTradingStrategy,
+                        )
+
+                        s = BasisTradingStrategy(
+                            config={
+                                "main_wallet": {"address": "0x1234"},
+                                "strategy_wallet": {"address": "0x5678"},
+                            },
+                        )
+                        s.hyperliquid_adapter = mock_hyperliquid_adapter
+                        s.ledger_adapter = ledger_adapter
+
+                        # Mock get_strategy_net_deposit to return float (not dict)
+                        s.ledger_adapter.get_strategy_net_deposit = AsyncMock(
+                            return_value=(True, 2500.0)
+                        )
+
+                        # Run setup - should not raise AttributeError
+                        await s.setup()
+
+                        # Verify deposit_amount was set from the float
+                        assert s.deposit_amount == 2500.0

wayfinder_paths/strategies/hyperlend_stable_yield_strategy/README.md

@@ -30,7 +30,6 @@ Allocates USDT0 on HyperEVM across HyperLend stablecoin markets. The strategy:
 - `LedgerAdapter` for net deposit + rotation history.
 - `BRAPAdapter` to source quotes/swap stablecoins.
 - `HyperlendAdapter` for asset views, lend/withdraw ops, supply caps.
-- `LocalTokenTxnService` via `DefaultWeb3Service` for low-level sends/approvals leveraged by the adapters.
 
 ## Actions
 

wayfinder_paths/strategies/hyperlend_stable_yield_strategy/strategy.py

@@ -2,6 +2,7 @@ import asyncio
 import math
 import time
 import unicodedata
+from collections.abc import Awaitable, Callable
 from datetime import UTC, datetime, timedelta, timezone
 from decimal import ROUND_DOWN, ROUND_UP, Decimal
 from typing import Any, Literal
@@ -17,11 +18,6 @@ from wayfinder_paths.adapters.hyperlend_adapter.adapter import HyperlendAdapter
 from wayfinder_paths.adapters.ledger_adapter.adapter import LedgerAdapter
 from wayfinder_paths.adapters.token_adapter.adapter import TokenAdapter
 from wayfinder_paths.core.constants.base import DEFAULT_SLIPPAGE
-from wayfinder_paths.core.services.base import Web3Service
-from wayfinder_paths.core.services.local_token_txn import (
-    LocalTokenTxnService,
-)
-from wayfinder_paths.core.services.web3_service import DefaultWeb3Service
 from wayfinder_paths.core.strategies.descriptors import (
     Complexity,
     Directionality,
@@ -31,7 +27,6 @@ from wayfinder_paths.core.strategies.descriptors import (
     Volatility,
 )
 from wayfinder_paths.core.strategies.Strategy import StatusDict, StatusTuple, Strategy
-from wayfinder_paths.core.wallets.WalletManager import WalletManager
 from wayfinder_paths.policies.enso import ENSO_ROUTER, enso_swap
 from wayfinder_paths.policies.erc20 import erc20_spender_for_any_token
 from wayfinder_paths.policies.hyper_evm import (
@@ -196,9 +191,16 @@ class HyperlendStableYieldStrategy(Strategy):
         *,
         main_wallet: dict[str, Any] | None = None,
         strategy_wallet: dict[str, Any] | None = None,
-        web3_service: Web3Service = 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__()
+        super().__init__(
+            api_key=api_key,
+            main_wallet_signing_callback=main_wallet_signing_callback,
+            strategy_wallet_signing_callback=strategy_wallet_signing_callback,
+        )
         merged_config: dict[str, Any] = dict(config or {})
         if main_wallet is not None:
             merged_config["main_wallet"] = main_wallet
@@ -207,10 +209,7 @@ class HyperlendStableYieldStrategy(Strategy):
 
         self.config = merged_config
         self.balance_adapter = None
-        self.tx_adapter = None
         self.token_adapter = None
-        self.evm_transaction_adapter = None
-        self.web3_service = web3_service
         self.pool_adapter = None
         self.brap_adapter = None
         self.hyperlend_adapter = None
@@ -231,26 +230,20 @@ class HyperlendStableYieldStrategy(Strategy):
                 "strategy": self.config,
             }
 
-            if self.web3_service is None:
-                wallet_provider = WalletManager.get_provider(adapter_config)
-                token_transaction_service = LocalTokenTxnService(
-                    adapter_config,
-                    wallet_provider=wallet_provider,
-                )
-                web3_service = DefaultWeb3Service(
-                    wallet_provider=wallet_provider,
-                    evm_transactions=token_transaction_service,
-                )
-            else:
-                web3_service = self.web3_service
-                token_transaction_service = web3_service.token_transactions
-            balance = BalanceAdapter(adapter_config, web3_service=web3_service)
+            balance = BalanceAdapter(
+                adapter_config,
+                main_wallet_signing_callback=self.main_wallet_signing_callback,
+                strategy_wallet_signing_callback=self.strategy_wallet_signing_callback,
+            )
             token_adapter = TokenAdapter()
-            ledger_adapter = LedgerAdapter()  # here
-            brap_adapter = BRAPAdapter(web3_service=web3_service)
+            ledger_adapter = LedgerAdapter()
+            brap_adapter = BRAPAdapter(
+                adapter_config,
+                strategy_wallet_signing_callback=self.strategy_wallet_signing_callback,
+            )
             hyperlend_adapter = HyperlendAdapter(
                 adapter_config,
-                web3_service=web3_service,
+                strategy_wallet_signing_callback=self.strategy_wallet_signing_callback,
             )
 
             self.register_adapters(
@@ -260,12 +253,9 @@ class HyperlendStableYieldStrategy(Strategy):
                     ledger_adapter,
                     brap_adapter,
                     hyperlend_adapter,
-                    token_transaction_service,
                 ]
             )
             self.balance_adapter = balance
-            self.evm_transaction_adapter = token_transaction_service
-            self.web3_service = web3_service
             self.token_adapter = token_adapter
             self.ledger_adapter = ledger_adapter
             self.brap_adapter = brap_adapter
@@ -719,8 +709,8 @@ class HyperlendStableYieldStrategy(Strategy):
                     result,
                     tx_data,
                 ) = await self.brap_adapter.swap_from_token_ids(
-                    from_query=from_token_id,
-                    to_query=to_token_id,
+                    from_token_id=from_token_id,
+                    to_token_id=to_token_id,
                     from_address=strategy_address,
                     amount=amount_wei_str,
                     slippage=slippage,
@@ -863,78 +853,131 @@ class HyperlendStableYieldStrategy(Strategy):
             self.usdt_token_info
         )
 
+        # Get final balances in strategy wallet (don't transfer to main)
+        total_usdt = 0.0
         try:
             _, total_usdt_wei = await self.balance_adapter.get_balance(
                 query=self.usdt_token_info.get("token_id"),
                 wallet_address=self._get_strategy_wallet_address(),
             )
-        except Exception:
-            total_usdt_wei = 0
-
-        if total_usdt_wei and total_usdt_wei > 0:
-            total_usdt = float(total_usdt_wei) / (
-                10 ** self.usdt_token_info.get("decimals", 18)
-            )
-            (
-                transfer_success,
-                transfer_message,
-            ) = await self.balance_adapter.move_from_strategy_wallet_to_main_wallet(
-                self.usdt_token_info.get("token_id"),
-                total_usdt,
-                strategy_name=self.name,
-            )
-            if transfer_success:
-                messages.append(
-                    f"Returned {total_usdt:.2f} {self.usdt_token_info.get('symbol')} from strategy wallet to main wallet"
-                )
-            else:
-                messages.append(
-                    "Returned USDT0 to ledger but on-chain transfer failed; treating as withdrawn for simulation"
+            if total_usdt_wei and total_usdt_wei > 0:
+                total_usdt = float(total_usdt_wei) / (
+                    10 ** self.usdt_token_info.get("decimals", 18)
                 )
+        except Exception:
+            pass
 
+        total_hype = 0.0
         try:
             _, total_hype_wei = await self.balance_adapter.get_balance(
                 query=self.hype_token_info.get("token_id"),
                 wallet_address=self._get_strategy_wallet_address(),
             )
-        except Exception:
-            total_hype_wei = 0
-
-        if total_hype_wei and total_hype_wei > 0:
-            total_hype = float(total_hype_wei) / (
-                10 ** self.hype_token_info.get("decimals", 18)
-            )
-            total_hype = total_hype * 0.9
-            (
-                transfer_success,
-                transfer_message,
-            ) = await self.balance_adapter.move_from_strategy_wallet_to_main_wallet(
-                self.hype_token_info.get("token_id"),
-                total_hype,
-                strategy_name=self.name,
-            )
-            if transfer_success:
-                messages.append(
-                    f"Returned {total_hype:.2f} {self.hype_token_info.get('symbol')} from strategy wallet to main wallet"
-                )
-            else:
-                messages.append(
-                    "Returned HYPE to ledger but on-chain transfer failed; treating as withdrawn for simulation"
+            if total_hype_wei and total_hype_wei > 0:
+                total_hype = float(total_hype_wei) / (
+                    10 ** self.hype_token_info.get("decimals", 18)
                 )
+        except Exception:
+            pass
 
         if sweep_actions:
             messages.append(f"Residual sweeps: {'; '.join(sweep_actions)}.")
 
-        if not messages:
-            messages.append("Withdrawal complete; no balances detected to transfer")
+        # Report balances in strategy wallet
+        balance_parts = []
+        if total_usdt > 0:
+            balance_parts.append(
+                f"{total_usdt:.2f} {self.usdt_token_info.get('symbol')}"
+            )
+        if total_hype > 0:
+            balance_parts.append(
+                f"{total_hype:.4f} {self.hype_token_info.get('symbol')}"
+            )
+
+        if balance_parts:
+            messages.append(f"Strategy wallet balance: {', '.join(balance_parts)}")
 
         self.current_token = None
         self.current_symbol = None
         self.current_avg_apy = 0.0
         self.kept_hype_tokens = 0.0
 
+        strategy_address = self._get_strategy_wallet_address()
+        messages.append(
+            f"Call exit() to transfer funds from strategy wallet ({strategy_address}) to main wallet"
+        )
+
         return (True, ". ".join(messages))
 
+    async def exit(self, **kwargs) -> StatusTuple:
+        """Transfer funds from strategy wallet to main wallet."""
+        self.logger.info("EXIT: Transferring remaining funds to main wallet")
+
+        strategy_address = self._get_strategy_wallet_address()
+        main_address = self._get_main_wallet_address()
+
+        if strategy_address.lower() == main_address.lower():
+            return (True, "Main wallet is strategy wallet, no transfer needed")
+
+        transferred_items = []
+
+        # Transfer USDT0 to main wallet
+        usdt_ok, usdt_raw = await self.balance_adapter.get_balance(
+            token_id="usdt0-hyperevm",
+            wallet_address=strategy_address,
+        )
+        if usdt_ok and usdt_raw:
+            usdt_balance = float(usdt_raw.get("balance", 0))
+            if usdt_balance > 1.0:
+                self.logger.info(
+                    f"Transferring {usdt_balance:.2f} USDT0 to main wallet"
+                )
+                (
+                    success,
+                    msg,
+                ) = await self.balance_adapter.move_from_strategy_wallet_to_main_wallet(
+                    query="usdt0-hyperevm",
+                    amount=usdt_balance,
+                    strategy_name=self.name,
+                    skip_ledger=False,
+                )
+                if success:
+                    transferred_items.append(f"{usdt_balance:.2f} USDT0")
+                else:
+                    self.logger.warning(f"USDT0 transfer failed: {msg}")
+
+        # Transfer HYPE (minus reserve for tx fees) to main wallet
+        hype_ok, hype_raw = await self.balance_adapter.get_balance(
+            token_id="hyperliquid-hyperevm",
+            wallet_address=strategy_address,
+        )
+        if hype_ok and hype_raw:
+            hype_balance = float(hype_raw.get("balance", 0))
+            tx_fee_reserve = 0.1  # Reserve 0.1 HYPE for tx fees
+            transferable_hype = hype_balance - tx_fee_reserve
+            if transferable_hype > 0.01:
+                self.logger.info(
+                    f"Transferring {transferable_hype:.4f} HYPE to main wallet"
+                )
+                (
+                    success,
+                    msg,
+                ) = await self.balance_adapter.move_from_strategy_wallet_to_main_wallet(
+                    query="hyperliquid-hyperevm",
+                    amount=transferable_hype,
+                    strategy_name=self.name,
+                    skip_ledger=False,
+                )
+                if success:
+                    transferred_items.append(f"{transferable_hype:.4f} HYPE")
+                else:
+                    self.logger.warning(f"HYPE transfer failed: {msg}")
+
+        if not transferred_items:
+            return (True, "No funds to transfer to main wallet")
+
+        return (True, f"Transferred to main wallet: {', '.join(transferred_items)}")
+
     async def _swap_residual_balances_to_token(
         self, token_info: dict[str, Any], include_native: bool = False
     ) -> list[str]: