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

wayfinder_paths/strategies/basis_trading_strategy/strategy.py

@@ -11,6 +11,7 @@ import asyncio
 import math
 import random
 import time
+from collections.abc import Awaitable, Callable
 from datetime import UTC, datetime, timedelta
 from decimal import ROUND_DOWN, ROUND_UP, Decimal, getcontext
 from pathlib import Path
@@ -60,9 +61,6 @@ from wayfinder_paths.core.analytics import (
 from wayfinder_paths.core.analytics import (
     z_from_conf as analytics_z_from_conf,
 )
-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,
@@ -72,7 +70,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.strategies.basis_trading_strategy.constants import (
     USDC_ARBITRUM_TOKEN_ID,
 )
@@ -116,8 +113,10 @@ class BasisTradingStrategy(BasisSnapshotMixin, Strategy):
     DEFAULT_BOOTSTRAP_BLOCK_HOURS = 48
 
     # Liquidation and rebalance thresholds
-    LIQUIDATION_REBALANCE_THRESHOLD = 0.75  # Trigger rebalance at 75% to liquidation
-    LIQUIDATION_STOP_LOSS_THRESHOLD = 0.90  # Stop-loss at 90% to liquidation (closer)
+    # Trigger rebalance at 75% to liquidation
+    LIQUIDATION_REBALANCE_THRESHOLD = 0.75
+    # Stop-loss at 90% to liquidation (closer)
+    LIQUIDATION_STOP_LOSS_THRESHOLD = 0.90
     FUNDING_REBALANCE_THRESHOLD = 0.02  # Rebalance when funding hits 2% gains
 
     # Position tolerances
@@ -201,10 +200,17 @@ class BasisTradingStrategy(BasisSnapshotMixin, Strategy):
         *,
         main_wallet: dict[str, Any] | None = None,
         strategy_wallet: dict[str, Any] | None = None,
-        web3_service: Web3Service | None = None,
         hyperliquid_executor: HyperliquidExecutor | 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,
     ) -> 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(config or {})
         if main_wallet:
@@ -262,19 +268,10 @@ class BasisTradingStrategy(BasisSnapshotMixin, Strategy):
 
         # Other adapters require a configured wallet provider / web3 service.
         try:
-            if web3_service is None:
-                wallet_provider = WalletManager.get_provider(adapter_config)
-                tx_adapter = LocalTokenTxnService(
-                    adapter_config,
-                    wallet_provider=wallet_provider,
-                )
-                web3_service = DefaultWeb3Service(
-                    wallet_provider=wallet_provider, evm_transactions=tx_adapter
-                )
-
-            self.web3_service = web3_service
             self.balance_adapter = BalanceAdapter(
-                adapter_config, web3_service=web3_service
+                adapter_config,
+                main_wallet_signing_callback=self.main_wallet_signing_callback,
+                strategy_wallet_signing_callback=self.strategy_wallet_signing_callback,
             )
             self.token_adapter = TokenAdapter()
             self.ledger_adapter = LedgerAdapter()
@@ -478,20 +475,18 @@ class BasisTradingStrategy(BasisSnapshotMixin, Strategy):
                 gas_ok,
                 gas_res,
             ) = await self.balance_adapter.move_from_main_wallet_to_strategy_wallet(
-                query="ethereum-arbitrum",  # Native ETH on Arbitrum
+                token_id="ethereum-arbitrum",  # Native ETH on Arbitrum
                 amount=gas_token_amount,
                 strategy_name=self.name or "basis_trading_strategy",
-                skip_ledger=True,
             )
             if not gas_ok:
                 self.logger.error(f"Failed to transfer ETH for gas: {gas_res}")
                 return (False, f"Failed to transfer ETH for gas: {gas_res}")
             self.logger.info(f"Gas transfer successful: {gas_res}")
 
-        # Real deposit: ensure funds are in the strategy wallet, then send USDC to bridge.
+        # Real deposit: ensure funds are in the strategy wallet.
         try:
             main_address = self._get_main_wallet_address()
-            strategy_wallet = self.config.get("strategy_wallet")
             strategy_address = self._get_strategy_wallet_address()
 
             # Check if strategy wallet already has sufficient USDC
@@ -517,10 +512,9 @@ class BasisTradingStrategy(BasisSnapshotMixin, Strategy):
                     move_ok,
                     move_res,
                 ) = await self.balance_adapter.move_from_main_wallet_to_strategy_wallet(
-                    query=USDC_ARBITRUM_TOKEN_ID,
+                    token_id=USDC_ARBITRUM_TOKEN_ID,
                     amount=need_to_move,
                     strategy_name=self.name or "basis_trading_strategy",
-                    skip_ledger=True,
                 )
                 if not move_ok:
                     self.logger.error(
@@ -535,73 +529,14 @@ class BasisTradingStrategy(BasisSnapshotMixin, Strategy):
                     f"Strategy wallet already has {strategy_usdc:.2f} USDC, skipping transfer from main"
                 )
 
-            self.logger.info(
-                f"Sending {main_token_amount} USDC from strategy wallet ({strategy_address}) "
-                f"to Hyperliquid bridge ({HYPERLIQUID_BRIDGE_ADDRESS})"
-            )
-
-            # Send USDC to bridge address (deposit credits the sender address on Hyperliquid)
-            success, result = await self.balance_adapter.send_to_address(
-                query=USDC_ARBITRUM_TOKEN_ID,
-                amount=main_token_amount,
-                from_wallet=strategy_wallet,
-                to_address=HYPERLIQUID_BRIDGE_ADDRESS,
-                skip_ledger=True,  # We'll record after HL credits the deposit
-            )
-
-            if not success:
-                self.logger.error(f"Failed to send USDC to bridge: {result}")
-                return (False, f"Failed to send USDC to bridge: {result}")
-
-            self.logger.info(f"USDC sent to bridge, tx: {result}")
-
-            # Wait for Hyperliquid to credit the deposit
-            self.logger.info("Waiting for Hyperliquid to credit the deposit...")
-
-            (
-                deposit_confirmed,
-                final_balance,
-            ) = await self.hyperliquid_adapter.wait_for_deposit(
-                address=strategy_address,
-                expected_increase=main_token_amount,
-                timeout_s=180,  # 3 minutes for initial deposit
-                poll_interval_s=10,
-            )
-
-            if not deposit_confirmed:
-                self.logger.warning(
-                    f"Deposit not confirmed within timeout. "
-                    f"Current HL balance: ${final_balance:.2f}. "
-                    f"Deposit may still be processing."
-                )
-                # Still track the deposit amount since we sent it
-                self.deposit_amount = main_token_amount
-                return (
-                    True,
-                    f"Sent {main_token_amount} USDC to bridge. Deposit still processing. "
-                    f"Current HL balance: ${final_balance:.2f}",
-                )
-
-            self.deposit_amount = main_token_amount
-
-            # Record in ledger
-            try:
-                await self.ledger_adapter.record_deposit(
-                    wallet_address=strategy_address,
-                    chain_id=42161,  # Arbitrum
-                    token_address="hyperliquid-vault-usd",  # Synthetic address for HL USD
-                    token_amount=str(main_token_amount),
-                    usd_value=main_token_amount,
-                    data={"destination": "hyperliquid_l1"},
-                    strategy_name=self.name,
-                )
-            except Exception as e:
-                self.logger.warning(f"Failed to record deposit in ledger: {e}")
+            # Accumulate deposit amount for bridging in update()
+            self.deposit_amount += main_token_amount
 
             return (
                 True,
-                f"Deposited {main_token_amount} USDC to Hyperliquid L1. "
-                f"Balance: ${final_balance:.2f}. Call update() to open positions.",
+                f"Transferred {main_token_amount} USDC to strategy wallet ({strategy_address}). "
+                f"Total deposits: ${self.deposit_amount:.2f}. "
+                f"Call update() to bridge to Hyperliquid and open positions.",
             )
 
         except Exception as e:
@@ -622,18 +557,92 @@ class BasisTradingStrategy(BasisSnapshotMixin, Strategy):
         Returns:
             StatusTuple (success, message)
         """
-        # If deposit_amount not set, try to detect from Hyperliquid USDC (spot + perp)
-        if self.deposit_amount <= 0:
+        # Check actual balances instead of relying on in-memory deposit_amount
+        strategy_address = self._get_strategy_wallet_address()
+        strategy_wallet = self.config.get("strategy_wallet")
+
+        # Check strategy wallet USDC balance on Arbitrum
+        strategy_usdc = 0.0
+        try:
+            (
+                strategy_balance_ok,
+                strategy_balance,
+            ) = await self.balance_adapter.get_balance(
+                query=USDC_ARBITRUM_TOKEN_ID,
+                wallet_address=strategy_address,
+            )
+            if strategy_balance_ok and strategy_balance:
+                strategy_usdc = float(strategy_balance) / 1e6
+        except Exception as e:
+            self.logger.warning(f"Could not check strategy wallet balance: {e}")
+
+        # Check Hyperliquid USDC balance (spot + perp)
+        hl_usdc = 0.0
+        try:
             perp_margin, spot_usdc = await self._get_undeployed_capital()
-            total_usdc = perp_margin + spot_usdc
-            if total_usdc > 1.0:
+            hl_usdc = perp_margin + spot_usdc
+        except Exception as e:
+            self.logger.warning(f"Could not check Hyperliquid balance: {e}")
+
+        # Update deposit_amount from actual balances
+        total_available = strategy_usdc + hl_usdc
+        if total_available > 1.0:
+            self.deposit_amount = max(self.deposit_amount, total_available)
+
+        if total_available < 1.0 and self.current_position is None:
+            return (False, "No funds to manage. Call deposit() first.")
+
+        # Bridge USDC from strategy wallet to Hyperliquid if needed
+        if strategy_usdc > 10.0:
+            try:
                 self.logger.info(
-                    f"Detected ${total_usdc:.2f} USDC on Hyperliquid (spot+perp), using as deposit amount"
+                    f"Found ${strategy_usdc:.2f} USDC in strategy wallet, bridging to Hyperliquid"
                 )
-                self.deposit_amount = total_usdc
 
-        if self.deposit_amount <= 0:
-            return (False, "No deposit to manage. Call deposit() first.")
+                # Send USDC to bridge address (internal operation, not a deposit event)
+                success, result = await self.balance_adapter.send_to_address(
+                    token_id=USDC_ARBITRUM_TOKEN_ID,
+                    amount=strategy_usdc,
+                    from_wallet=strategy_wallet,
+                    to_address=HYPERLIQUID_BRIDGE_ADDRESS,
+                )
+
+                if not success:
+                    self.logger.error(f"Failed to send USDC to bridge: {result}")
+                    return (False, f"Failed to bridge USDC to Hyperliquid: {result}")
+
+                self.logger.info(f"USDC sent to bridge, tx: {result}")
+
+                # Wait for Hyperliquid to credit the deposit
+                self.logger.info("Waiting for Hyperliquid to credit the deposit...")
+
+                (
+                    deposit_confirmed,
+                    final_balance,
+                ) = await self.hyperliquid_adapter.wait_for_deposit(
+                    address=strategy_address,
+                    expected_increase=strategy_usdc,
+                    timeout_s=180,  # 3 minutes
+                    poll_interval_s=10,
+                )
+
+                if not deposit_confirmed:
+                    self.logger.warning(
+                        f"Deposit not confirmed within timeout. "
+                        f"Current HL balance: ${final_balance:.2f}. "
+                        f"Deposit may still be processing."
+                    )
+                    return (
+                        True,
+                        f"Sent ${strategy_usdc:.2f} USDC to bridge. Deposit still processing. "
+                        f"Current HL balance: ${final_balance:.2f}. Call update() again.",
+                    )
+
+                self.logger.info(
+                    f"Successfully bridged ${strategy_usdc:.2f} USDC to Hyperliquid"
+                )
+            except Exception as e:
+                self.logger.warning(f"Failed to bridge USDC to Hyperliquid: {e}")
 
         # If no position, find and open one
         if self.current_position is None:
@@ -797,14 +806,55 @@ class BasisTradingStrategy(BasisSnapshotMixin, Strategy):
             return nested.get(key, default)
         return default
 
+    def _resolve_mid_price(self, coin: str, mid_prices: dict[str, float]) -> float:
+        """Resolve mid price with U-prefix handling for universal spot tokens.
+
+        Spot balances may return U-prefixed coin names (e.g., UXPL) while mid prices
+        are keyed by non-prefixed names (e.g., XPL). This helper handles the mismatch.
+        """
+        # Direct match
+        if coin in mid_prices:
+            return mid_prices[coin]
+
+        # Case variations
+        for key in [coin.upper(), coin.lower()]:
+            if key in mid_prices:
+                return mid_prices[key]
+
+        # Strip U-prefix (UXPL -> XPL)
+        if coin.startswith("U") and len(coin) > 1:
+            stripped = coin[1:]
+            for key in [stripped, stripped.upper(), stripped.lower()]:
+                if key in mid_prices:
+                    return mid_prices[key]
+
+        # Add U-prefix (XPL -> UXPL)
+        prefixed = f"U{coin}"
+        for key in [prefixed, prefixed.upper(), prefixed.lower()]:
+            if key in mid_prices:
+                return mid_prices[key]
+
+        return 0.0
+
+    def _coins_match(self, coin1: str, coin2: str) -> bool:
+        """Check if two coin names match, handling U-prefix (UXPL == XPL)."""
+        if coin1 == coin2:
+            return True
+        # Strip U-prefix from either and compare
+        c1 = coin1[1:] if coin1.startswith("U") and len(coin1) > 1 else coin1
+        c2 = coin2[1:] if coin2.startswith("U") and len(coin2) > 1 else coin2
+        return c1 == c2
+
     async def withdraw(self, amount: float | None = None) -> StatusTuple:
         """
-        Close all positions and return funds to main wallet.
+        Close all positions and liquidate to strategy wallet.
 
         Handles funds in:
         1. Strategy wallet on Arbitrum (USDC)
         2. Hyperliquid L1 (positions + margin)
 
+        Does NOT transfer to main wallet - call exit() for that.
+
         Args:
             amount: Amount to withdraw (None = all)
 
@@ -812,9 +862,7 @@ class BasisTradingStrategy(BasisSnapshotMixin, Strategy):
             StatusTuple (success, message)
         """
         address = self._get_strategy_wallet_address()
-        main_address = self._get_main_wallet_address()
         usdc_token_id = "usd-coin-arbitrum"
-        total_withdrawn = 0.0
 
         # Check for USDC already in strategy wallet on Arbitrum
         strategy_usdc = 0.0
@@ -852,44 +900,14 @@ class BasisTradingStrategy(BasisSnapshotMixin, Strategy):
         if strategy_usdc < 1.0 and hl_value < 1.0 and self.current_position is None:
             return (False, "Nothing to withdraw")
 
-        # Step 0: Send any USDC already in strategy wallet to main wallet
-        if strategy_usdc > 1.0 and main_address.lower() != address.lower():
-            amount_to_send = strategy_usdc  # Send full amount
-            self.logger.info(
-                f"Found ${strategy_usdc:.2f} USDC in strategy wallet, "
-                f"sending ${amount_to_send:.2f} to main wallet"
-            )
-
-            try:
-                (
-                    send_success,
-                    send_result,
-                ) = await self.balance_adapter.move_from_strategy_wallet_to_main_wallet(
-                    query=usdc_token_id,
-                    amount=amount_to_send,
-                    strategy_name=self.name,
-                    skip_ledger=False,
-                )
-
-                if send_success:
-                    self.logger.info(f"Sent ${amount_to_send:.2f} USDC to main wallet")
-                    total_withdrawn += amount_to_send
-                else:
-                    self.logger.warning(
-                        f"Failed to send USDC to main wallet: {send_result}"
-                    )
-            except Exception as e:
-                self.logger.error(f"Error sending USDC to main wallet: {e}")
-
-        # If nothing on Hyperliquid, we're done
+        # If nothing on Hyperliquid, we're done - funds already in strategy wallet
         if hl_value < 1.0 and self.current_position is None:
             self.deposit_amount = 0
-            if total_withdrawn > 0:
-                return (
-                    True,
-                    f"Sent ${total_withdrawn:.2f} USDC to main wallet ({main_address})",
-                )
-            return (True, "No funds on Hyperliquid to withdraw")
+            return (
+                True,
+                f"${strategy_usdc:.2f} USDC in strategy wallet ({address}). "
+                f"Call exit() to transfer to main wallet.",
+            )
 
         # Close any open position
         if self.current_position is not None:
@@ -898,23 +916,50 @@ class BasisTradingStrategy(BasisSnapshotMixin, Strategy):
                 return (False, f"Failed to close position: {close_msg}")
 
         # Step 1: Transfer any spot USDC to perp for withdrawal
-        success, spot_state = await self.hyperliquid_adapter.get_spot_user_state(
-            address
-        )
-        if success:
+        # Wait for spot sale to settle before checking balance
+        await asyncio.sleep(5)
+
+        for _transfer_attempt in range(3):
+            success, spot_state = await self.hyperliquid_adapter.get_spot_user_state(
+                address
+            )
+            if not success:
+                continue
+
             spot_balances = spot_state.get("balances", [])
             for bal in spot_balances:
                 if bal.get("coin") == "USDC":
-                    spot_usdc = float(bal.get("total", 0))
+                    # Use available balance (total - hold), not total
+                    total = float(bal.get("total", 0))
+                    hold = float(bal.get("hold", 0))
+                    available = total - hold
+
+                    # Floor to 2 decimal places to avoid precision issues
+                    spot_usdc = math.floor(available * 100) / 100
+
                     if spot_usdc > 1.0:  # Only transfer if meaningful amount
                         self.logger.info(
-                            f"Transferring ${spot_usdc:.2f} from spot to perp"
+                            f"Transferring ${spot_usdc:.2f} from spot to perp "
+                            f"(available={available:.8f}, floored={spot_usdc:.2f})"
                         )
-                        await self.hyperliquid_adapter.transfer_spot_to_perp(
+                        (
+                            transfer_ok,
+                            transfer_result,
+                        ) = await self.hyperliquid_adapter.transfer_spot_to_perp(
                             amount=spot_usdc,
                             address=address,
                         )
+                        if transfer_ok:
+                            self.logger.info("Spot to perp transfer successful")
+                        else:
+                            self.logger.warning(
+                                f"Spot to perp transfer failed: {transfer_result}. "
+                                f"Retrying after delay..."
+                            )
+                            await asyncio.sleep(5)
+                            continue
                     break
+            break
 
         # Step 2: Get updated perp balance for withdrawal (with retry)
         # Wait a moment for transfers to settle
@@ -982,31 +1027,10 @@ class BasisTradingStrategy(BasisSnapshotMixin, Strategy):
             f"Withdrawal confirmed: tx={tx_hash}, amount=${withdrawn_amount:.2f}"
         )
 
-        # Record withdrawal in ledger
-        try:
-            await self.ledger_adapter.record_withdrawal(
-                wallet_address=address,
-                chain_id=42161,  # Arbitrum
-                token_address="hyperliquid-vault-usd",
-                token_amount=str(withdrawn_amount),
-                usd_value=withdrawn_amount,
-                data={
-                    "source": "hyperliquid_l1",
-                    "destination": "arbitrum",
-                    "tx_hash": tx_hash,
-                },
-                strategy_name=self.name,
-            )
-            self.logger.info(
-                f"Recorded withdrawal of ${withdrawn_amount:.2f} in ledger"
-            )
-        except Exception as e:
-            self.logger.warning(f"Failed to record withdrawal in ledger: {e}")
-
         # Step 5: Wait a bit for the USDC to be credited on Arbitrum
         await asyncio.sleep(10)
 
-        # Get final USDC balance
+        # Get final USDC balance in strategy wallet
         final_balance = 0.0
         try:
             success, balance_data = await self.balance_adapter.get_balance(
@@ -1018,59 +1042,81 @@ class BasisTradingStrategy(BasisSnapshotMixin, Strategy):
         except Exception as e:
             self.logger.warning(f"Could not get final balance: {e}")
 
-        # Step 6: Send USDC from strategy wallet to main wallet
-        amount_to_send = final_balance  # Send full amount
+        self.deposit_amount = 0
+        self.current_position = None
+
+        return (
+            True,
+            f"Withdrew ${withdrawn_amount:.2f} from Hyperliquid to strategy wallet ({address}). "
+            f"Current balance: ${final_balance:.2f}. Call exit() to transfer to main wallet.",
+        )
 
-        if amount_to_send > 1.0 and main_address.lower() != address.lower():
-            self.logger.info(
-                f"Sending ${amount_to_send:.2f} USDC from strategy wallet to main wallet"
-            )
+    async def exit(self, **kwargs) -> StatusTuple:
+        """Transfer funds from strategy wallet to main wallet."""
+        self.logger.info("EXIT: Transferring remaining funds to main wallet")
 
-            try:
+        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 USDC to main wallet
+        usdc_ok, usdc_raw = await self.balance_adapter.get_balance(
+            token_id=USDC_ARBITRUM_TOKEN_ID,
+            wallet_address=strategy_address,
+        )
+        if usdc_ok and usdc_raw:
+            usdc_balance = float(usdc_raw.get("balance", 0))
+            if usdc_balance > 1.0:
+                self.logger.info(f"Transferring {usdc_balance:.2f} USDC to main wallet")
                 (
-                    send_success,
-                    send_result,
+                    success,
+                    msg,
                 ) = await self.balance_adapter.move_from_strategy_wallet_to_main_wallet(
-                    query=usdc_token_id,
-                    amount=amount_to_send,
+                    query=USDC_ARBITRUM_TOKEN_ID,
+                    amount=usdc_balance,
                     strategy_name=self.name,
-                    skip_ledger=False,  # Record in ledger
+                    skip_ledger=False,
                 )
-
-                if send_success:
-                    self.logger.info(
-                        f"Successfully sent ${amount_to_send:.2f} USDC to main wallet"
-                    )
-                    total_withdrawn += amount_to_send
+                if success:
+                    transferred_items.append(f"{usdc_balance:.2f} USDC")
                 else:
-                    self.logger.warning(
-                        f"Failed to send USDC to main wallet: {send_result}"
-                    )
-                    return (
-                        True,
-                        f"Withdrew ${withdrawable:.2f} from Hyperliquid but failed to send to main wallet: {send_result}. "
-                        f"USDC is in strategy wallet ({address}).",
-                    )
-            except Exception as e:
-                self.logger.error(f"Error sending to main wallet: {e}")
-                return (
-                    True,
-                    f"Withdrew ${withdrawable:.2f} from Hyperliquid but error sending to main wallet: {e}. "
-                    f"USDC is in strategy wallet ({address}).",
+                    self.logger.warning(f"USDC transfer failed: {msg}")
+
+        # Transfer ETH (minus reserve for tx fees) to main wallet
+        eth_ok, eth_raw = await self.balance_adapter.get_balance(
+            token_id="ethereum-arbitrum",
+            wallet_address=strategy_address,
+        )
+        if eth_ok and eth_raw:
+            eth_balance = float(eth_raw.get("balance", 0))
+            tx_fee_reserve = 0.0002
+            transferable_eth = eth_balance - tx_fee_reserve
+            if transferable_eth > 0.0001:
+                self.logger.info(
+                    f"Transferring {transferable_eth:.6f} ETH to main wallet"
                 )
-        elif main_address.lower() == address.lower():
-            self.logger.info("Main wallet is strategy wallet, no transfer needed")
-            total_withdrawn += withdrawable
-        else:
-            self.logger.warning(f"Amount too small to transfer: ${amount_to_send:.2f}")
+                (
+                    success,
+                    msg,
+                ) = await self.balance_adapter.move_from_strategy_wallet_to_main_wallet(
+                    query="ethereum-arbitrum",
+                    amount=transferable_eth,
+                    strategy_name=self.name,
+                    skip_ledger=False,
+                )
+                if success:
+                    transferred_items.append(f"{transferable_eth:.6f} ETH")
+                else:
+                    self.logger.warning(f"ETH transfer failed: {msg}")
 
-        self.deposit_amount = 0
-        self.current_position = None
+        if not transferred_items:
+            return (True, "No funds to transfer to main wallet")
 
-        return (
-            True,
-            f"Withdrew ${total_withdrawn:.2f} total to main wallet ({main_address}).",
-        )
+        return (True, f"Transferred to main wallet: {', '.join(transferred_items)}")
 
     async def _status(self) -> StatusDict:
         """Return portfolio value and strategy status with live data."""
@@ -1386,7 +1432,7 @@ class BasisTradingStrategy(BasisSnapshotMixin, Strategy):
 
             # Get entry price from current mid
             success, mids = await self.hyperliquid_adapter.get_all_mid_prices()
-            entry_price = mids.get(coin, 0.0) if success else 0.0
+            entry_price = self._resolve_mid_price(coin, mids) if success else 0.0
 
             # Step 5: Get liquidation price and place stop-loss
             success, user_state = await self.hyperliquid_adapter.get_user_state(address)
@@ -1576,7 +1622,7 @@ class BasisTradingStrategy(BasisSnapshotMixin, Strategy):
         if not success:
             return False, "Failed to get mid prices"
 
-        price = mids.get(pos.coin, 0.0)
+        price = self._resolve_mid_price(pos.coin, mids)
         if price <= 0:
             return False, f"Invalid price for {pos.coin}"
 
@@ -1843,7 +1889,7 @@ class BasisTradingStrategy(BasisSnapshotMixin, Strategy):
         if not success:
             return False, "Failed to fetch mid prices"
 
-        mid_px = float(mids.get(coin, 0.0) or 0.0)
+        mid_px = float(self._resolve_mid_price(coin, mids) or 0.0)
         if mid_px <= 0:
             return False, "Missing mid price"
 
@@ -1890,7 +1936,7 @@ class BasisTradingStrategy(BasisSnapshotMixin, Strategy):
         spot_size = 0.0
         if success:
             for bal in spot_state.get("balances", []):
-                if bal.get("coin") == coin:
+                if self._coins_match(bal.get("coin", ""), coin):
                     spot_size = float(bal.get("total", 0))
                     break
 
@@ -1949,7 +1995,7 @@ class BasisTradingStrategy(BasisSnapshotMixin, Strategy):
         spot_size = 0.0
         if success:
             for bal in spot_state.get("balances", []):
-                if bal.get("coin") == coin:
+                if self._coins_match(bal.get("coin", ""), coin):
                     spot_size = float(bal.get("total", 0))
                     break
 
@@ -1961,7 +2007,7 @@ class BasisTradingStrategy(BasisSnapshotMixin, Strategy):
         success, mids = await self.hyperliquid_adapter.get_all_mid_prices()
         if not success:
             return False, "Failed to get mid prices"
-        price = mids.get(coin, 0)
+        price = self._resolve_mid_price(coin, mids)
         if price <= 0:
             return False, f"Invalid price for {coin}"
 
@@ -2257,10 +2303,7 @@ class BasisTradingStrategy(BasisSnapshotMixin, Strategy):
         balances = spot_state.get("balances", [])
         for bal in balances:
             coin = bal.get("coin", "")
-            # Match by stripping /USDC suffix or checking against coin name
-            if coin == self.current_position.coin or coin.startswith(
-                self.current_position.coin
-            ):
+            if self._coins_match(coin, self.current_position.coin):
                 bal["asset_id"] = self.current_position.spot_asset_id
                 return bal
 
@@ -2555,7 +2598,7 @@ class BasisTradingStrategy(BasisSnapshotMixin, Strategy):
                         hl_value += total
                     else:
                         # Look up mid price for non-USDC assets
-                        mid_price = mid_prices.get(coin, 0.0)
+                        mid_price = self._resolve_mid_price(coin, mid_prices)
                         if mid_price > 0:
                             hl_value += total * mid_price
                         else: