wayfinder-paths 0.1.11__py3-none-any.whl → 0.1.13__py3-none-any.whl

wayfinder_paths/strategies/basis_trading_strategy/strategy.py

@@ -12,16 +12,15 @@ import math
 import random
 import time
 from datetime import UTC, datetime, timedelta
-from decimal import ROUND_UP, Decimal, getcontext
+from decimal import ROUND_DOWN, ROUND_UP, Decimal, getcontext
 from pathlib import Path
-from statistics import fmean, mean, pstdev
+from statistics import fmean
 from typing import Any
 
 from wayfinder_paths.adapters.balance_adapter.adapter import BalanceAdapter
 from wayfinder_paths.adapters.hyperliquid_adapter.adapter import (
     HYPERLIQUID_BRIDGE_ADDRESS,
     HyperliquidAdapter,
-    SimpleCache,
 )
 from wayfinder_paths.adapters.hyperliquid_adapter.executor import (
     HyperliquidExecutor,
@@ -44,9 +43,6 @@ from wayfinder_paths.adapters.hyperliquid_adapter.utils import (
 from wayfinder_paths.adapters.hyperliquid_adapter.utils import (
     spot_index_from_asset_id as hl_spot_index_from_asset_id,
 )
-from wayfinder_paths.adapters.hyperliquid_adapter.utils import (
-    sz_decimals_for_asset as hl_sz_decimals_for_asset,
-)
 from wayfinder_paths.adapters.hyperliquid_adapter.utils import (
     usd_depth_in_band as hl_usd_depth_in_band,
 )
@@ -91,10 +87,6 @@ from wayfinder_paths.strategies.basis_trading_strategy.types import (
 # Set decimal precision for precise price/size calculations
 getcontext().prec = 28
 
-# Hyperliquid price decimal limits
-MAX_DECIMALS_PERP = 6
-MAX_DECIMALS_SPOT = 8
-
 
 def _d(x: float | Decimal | str) -> Decimal:
     """Convert to Decimal for precise calculations."""
@@ -115,21 +107,20 @@ class BasisTradingStrategy(BasisSnapshotMixin, Strategy):
     # Strategy parameters
     MIN_DEPOSIT_USDC = 25
     DEFAULT_LOOKBACK_DAYS = 30  # Supports up to ~208 days via chunked API calls
-    DEFAULT_CONFIDENCE = 0.975
     DEFAULT_FEE_EPS = 0.003  # 0.3% fee buffer
-    DEFAULT_OI_FLOOR = 100_000.0  # Min OI in USD (matches Django)
+    DEFAULT_OI_FLOOR = 100_000.0  # Min OI in USD
     DEFAULT_DAY_VLM_FLOOR = 100_000  # Min daily volume
     DEFAULT_MAX_LEVERAGE = 2
     GAS_MAXIMUM = 0.01  # ETH
     DEFAULT_BOOTSTRAP_SIMS = 50
     DEFAULT_BOOTSTRAP_BLOCK_HOURS = 48
 
-    # Liquidation and rebalance thresholds (from Django funding_rate_strategy.py)
+    # 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)
     FUNDING_REBALANCE_THRESHOLD = 0.02  # Rebalance when funding hits 2% gains
 
-    # Position tolerances (from Django hyperliquid_adapter.py)
+    # Position tolerances
     SPOT_POSITION_DUST_TOLERANCE = 0.04  # ±4% size drift allowed
     MIN_UNUSED_USD = 5.0  # Minimum idle USD threshold
     UNUSED_REL_EPS = 0.01  # 1% of bankroll idle threshold
@@ -157,6 +148,8 @@ class BasisTradingStrategy(BasisSnapshotMixin, Strategy):
             "Automated delta-neutral basis trading on Hyperliquid, capturing funding rate payments "
             "through matched spot long / perp short positions with intelligent leverage sizing."
         ),
+        risk_description="Protocol risk is always present when engaging with DeFi strategies, this includes underlying DeFi protocols and Wayfinder itself. Additional risks include funding rate reversals, liquidity constraints on Hyperliquid, smart contract risk, and temporary capital lock-up during volatile market conditions. During extreme price movements, high volatility can stop out the short side of positions, breaking delta-neutrality and leaving unhedged long exposure that suffers losses when prices revert downward. This can cause significant damage beyond normal funding rate fluctuations.",
+        fee_description="Wayfinder takes a 2 basis point (0.02%) builder fee on all orders placed on Hyperliquid through this strategy. If fees remain unpaid, Wayfinder may pause automated management of this vault.",
         gas_token_symbol="ETH",
         gas_token_id="ethereum-arbitrum",
         deposit_token_id="usd-coin-arbitrum",
@@ -231,8 +224,6 @@ class BasisTradingStrategy(BasisSnapshotMixin, Strategy):
             "builder_fee", self.DEFAULT_BUILDER_FEE
         )
 
-        # Initialize cache
-        self._cache = SimpleCache()
         self._margin_table_cache: dict[int, list[dict[str, float]]] = {}
 
         # Adapters (some are optional for analysis-only usage).
@@ -315,8 +306,8 @@ class BasisTradingStrategy(BasisSnapshotMixin, Strategy):
             success, deposit_data = await self.ledger_adapter.get_strategy_net_deposit(
                 wallet_address=self._get_strategy_wallet_address()
             )
-            if success and deposit_data:
-                self.deposit_amount = float(deposit_data.get("net_deposit", 0) or 0)
+            if success and deposit_data is not None:
+                self.deposit_amount = float(deposit_data)
         except Exception as e:
             self.logger.warning(f"Could not fetch deposit data: {e}")
 
@@ -632,18 +623,15 @@ class BasisTradingStrategy(BasisSnapshotMixin, Strategy):
         Returns:
             StatusTuple (success, message)
         """
-        # If deposit_amount not set, try to detect from Hyperliquid balance
+        # If deposit_amount not set, try to detect from Hyperliquid USDC (spot + perp)
         if self.deposit_amount <= 0:
-            address = self._get_strategy_wallet_address()
-            success, user_state = await self.hyperliquid_adapter.get_user_state(address)
-            if success:
-                margin_summary = user_state.get("marginSummary", {})
-                account_value = float(margin_summary.get("accountValue", 0))
-                if account_value > 1.0:
-                    self.logger.info(
-                        f"Detected ${account_value:.2f} on Hyperliquid, using as deposit amount"
-                    )
-                    self.deposit_amount = account_value
+            perp_margin, spot_usdc = await self._get_undeployed_capital()
+            total_usdc = perp_margin + spot_usdc
+            if total_usdc > 1.0:
+                self.logger.info(
+                    f"Detected ${total_usdc:.2f} USDC on Hyperliquid (spot+perp), using as deposit amount"
+                )
+                self.deposit_amount = total_usdc
 
         if self.deposit_amount <= 0:
             return (False, "No deposit to manage. Call deposit() first.")
@@ -662,7 +650,7 @@ class BasisTradingStrategy(BasisSnapshotMixin, Strategy):
         Analyze basis trading opportunities without executing.
 
         Uses the Net-APY + stop-churn backtest solver with block-bootstrap
-        resampling (ported from Django's NetApyBasisTradingService).
+        resampling.
 
         Args:
             deposit_usdc: Hypothetical deposit amount for sizing calculations (default $1000)
@@ -1113,8 +1101,8 @@ class BasisTradingStrategy(BasisSnapshotMixin, Strategy):
                 wallet_address=self._get_strategy_wallet_address()
             )
             net_deposit = (
-                float(deposit_data.get("net_deposit", 0) or 0)
-                if success
+                float(deposit_data)
+                if success and deposit_data is not None
                 else self.deposit_amount
             )
         except Exception:
@@ -1207,6 +1195,13 @@ class BasisTradingStrategy(BasisSnapshotMixin, Strategy):
         self.logger.info("Analyzing basis trading opportunities...")
 
         try:
+            # Use actual on-exchange USDC (spot + perp) for sizing when opening a fresh position.
+            # This handles liquidation scenarios where most USDC ends up in spot.
+            perp_margin, spot_usdc = await self._get_undeployed_capital()
+            total_usdc = perp_margin + spot_usdc
+            if total_usdc > 1.0:
+                self.deposit_amount = total_usdc
+
             best: dict[str, Any] | None = None
 
             snapshot = self._snapshot_from_config()
@@ -1350,21 +1345,14 @@ class BasisTradingStrategy(BasisSnapshotMixin, Strategy):
                 self.logger.warning(f"Failed to set leverage: {lev_result}")
                 # Continue anyway - leverage might already be set
 
-            # Step 3: Transfer USDC from perp to spot for spot purchase
-            # We need approximately order_usd in spot to buy the asset
-            self.logger.info(
-                f"Transferring ${order_usd:.2f} from perp to spot for {coin}"
-            )
-            (
-                success,
-                transfer_result,
-            ) = await self.hyperliquid_adapter.transfer_perp_to_spot(
-                amount=order_usd,
+            # Step 3: Ensure USDC is split correctly between spot and perp.
+            # Target: spot has order_usd for the spot buy, perp holds the remainder as margin.
+            split_ok, split_msg = await self._rebalance_usdc_between_perp_and_spot(
+                target_spot_usdc=order_usd,
                 address=address,
             )
-            if not success:
-                self.logger.warning(f"Perp to spot transfer failed: {transfer_result}")
-                # May fail if already in spot, continue
+            if not split_ok:
+                self.logger.warning(f"USDC rebalance failed: {split_msg}")
 
             # Step 4: Execute paired fill
             filler = PairedFiller(
@@ -1378,8 +1366,8 @@ class BasisTradingStrategy(BasisSnapshotMixin, Strategy):
                 perp_filled,
                 spot_notional,
                 perp_notional,
-                spot_pointers,
-                perp_pointers,
+                _spot_pointers,
+                _perp_pointers,
             ) = await filler.fill_pair_units(
                 coin=coin,
                 spot_asset_id=spot_asset_id,
@@ -1488,6 +1476,76 @@ class BasisTradingStrategy(BasisSnapshotMixin, Strategy):
 
         return withdrawable, spot_usdc
 
+    async def _rebalance_usdc_between_perp_and_spot(
+        self,
+        *,
+        target_spot_usdc: float,
+        address: str,
+    ) -> tuple[bool, str]:
+        """
+        Rebalance Hyperliquid USDC between spot and perp to hit a target spot USDC balance.
+
+        Used before opening/scaling a basis position so we can:
+          - fund the spot buy (spot USDC ~= target_spot_usdc)
+          - keep the remainder in perp as margin (perp USDC ~= total - target_spot_usdc)
+        """
+        if target_spot_usdc <= 0:
+            return False, "Target spot USDC must be positive"
+
+        perp_margin, spot_usdc = await self._get_undeployed_capital()
+        total_usdc = perp_margin + spot_usdc
+        if total_usdc <= 0:
+            return False, "No deployable USDC on Hyperliquid"
+
+        # Operate at cent precision to avoid dust churn.
+        eps = 0.01
+        target = float(
+            Decimal(str(target_spot_usdc)).quantize(Decimal("0.01"), rounding=ROUND_UP)
+        )
+
+        if target > total_usdc + eps:
+            return (
+                False,
+                f"Target spot ${target:.2f} exceeds total deployable ${total_usdc:.2f}",
+            )
+
+        delta = target - spot_usdc
+        if abs(delta) < eps:
+            return True, "Spot/perp USDC already balanced"
+
+        if delta > 0:
+            # Need more spot USDC: move from perp to spot.
+            amount = float(
+                Decimal(str(min(delta, perp_margin))).quantize(
+                    Decimal("0.01"), rounding=ROUND_UP
+                )
+            )
+            if amount < eps:
+                return True, "No meaningful perp->spot transfer needed"
+            success, result = await self.hyperliquid_adapter.transfer_perp_to_spot(
+                amount=amount,
+                address=address,
+            )
+            if not success:
+                return False, f"Perp->spot transfer failed: {result}"
+            return True, f"Transferred ${amount:.2f} perp->spot"
+
+        # Need more perp USDC: move from spot to perp.
+        amount = float(
+            Decimal(str(min(-delta, spot_usdc))).quantize(
+                Decimal("0.01"), rounding=ROUND_DOWN
+            )
+        )
+        if amount < eps:
+            return True, "No meaningful spot->perp transfer needed"
+        success, result = await self.hyperliquid_adapter.transfer_spot_to_perp(
+            amount=amount,
+            address=address,
+        )
+        if not success:
+            return False, f"Spot->perp transfer failed: {result}"
+        return True, f"Transferred ${amount:.2f} spot->perp"
+
     async def _scale_up_position(self, additional_capital: float) -> StatusTuple:
         """
         Add capital to existing position without breaking it.
@@ -1553,18 +1611,14 @@ class BasisTradingStrategy(BasisSnapshotMixin, Strategy):
             f"(${order_usd:.2f}) at {leverage}x leverage"
         )
 
-        # Transfer USDC from perp to spot for the spot purchase
-        perp_margin, spot_usdc = await self._get_undeployed_capital()
-
-        if perp_margin > 1.0 and spot_usdc < order_usd:
-            # Need to move some from perp margin to spot
-            transfer_amount = min(perp_margin, order_usd - spot_usdc)
-            success, result = await self.hyperliquid_adapter.transfer_perp_to_spot(
-                amount=transfer_amount,
-                address=address,
-            )
-            if not success:
-                self.logger.warning(f"Perp to spot transfer failed: {result}")
+        # Ensure idle USDC is split correctly between spot and perp for this scale-up.
+        # Target: spot has order_usd for the spot buy, perp holds the remainder as margin.
+        split_ok, split_msg = await self._rebalance_usdc_between_perp_and_spot(
+            target_spot_usdc=order_usd,
+            address=address,
+        )
+        if not split_ok:
+            self.logger.warning(f"USDC rebalance failed: {split_msg}")
 
         # Execute paired fill to add to both legs
         filler = PairedFiller(
@@ -1645,6 +1699,22 @@ class BasisTradingStrategy(BasisSnapshotMixin, Strategy):
         # Calculate deposited amount from current on-exchange value
         total_value, hl_value, _ = await self._get_total_portfolio_value()
 
+        # ------------------------------------------------------------------ #
+        # Emergency: Near-liquidation risk management                         #
+        # ------------------------------------------------------------------ #
+        near_liq, near_msg = await self._is_near_liquidation(state)
+        if near_liq:
+            self.logger.warning(f"Near liquidation on {coin}: {near_msg}")
+            # Close both legs (sell spot, buy perp) and redeploy into a fresh position.
+            # This bypasses rotation cooldown because it's an emergency safety action.
+            close_success, close_msg = await self._close_position()
+            if not close_success:
+                return (
+                    False,
+                    f"Emergency rebalance failed - could not close: {close_msg}",
+                )
+            return await self._find_and_open_position()
+
         # ------------------------------------------------------------------ #
         # Check 1: Rebalance needed?                                          #
         # ------------------------------------------------------------------ #
@@ -1728,6 +1798,70 @@ class BasisTradingStrategy(BasisSnapshotMixin, Strategy):
             f"Position on {coin} healthy, age: {position_age_hours:.1f}h",
         )
 
+    async def _is_near_liquidation(self, state: dict[str, Any]) -> tuple[bool, str]:
+        """
+        Check whether the perp leg is too close to liquidation.
+
+        For a short perp, liquidation is ABOVE entry. We measure progress from entry -> liquidation:
+          frac = (mid - entry) / (liq - entry)
+        """
+        if self.current_position is None:
+            return False, "No position"
+
+        coin = self.current_position.coin
+
+        perp_pos = None
+        for pos_wrapper in state.get("assetPositions", []):
+            pos = pos_wrapper.get("position", {})
+            if pos.get("coin") == coin:
+                perp_pos = pos
+                break
+
+        if not perp_pos:
+            return False, "No perp position found"
+
+        try:
+            szi = float(perp_pos.get("szi", 0) or 0)
+        except (TypeError, ValueError):
+            szi = 0.0
+
+        # Only applies to short perps (basis trade is short perp).
+        if szi >= 0:
+            return False, "Perp is not short"
+
+        entry_px_raw = perp_pos.get("entryPx") or self.current_position.entry_price
+        liq_px_raw = perp_pos.get("liquidationPx")
+        try:
+            entry_px = float(entry_px_raw or 0)
+            liq_px = float(liq_px_raw or 0)
+        except (TypeError, ValueError):
+            return False, "Missing entry/liquidation price"
+
+        if entry_px <= 0 or liq_px <= 0 or liq_px <= entry_px:
+            return False, "Invalid entry/liquidation prices"
+
+        success, mids = await self.hyperliquid_adapter.get_all_mid_prices()
+        if not success:
+            return False, "Failed to fetch mid prices"
+
+        mid_px = float(mids.get(coin, 0.0) or 0.0)
+        if mid_px <= 0:
+            return False, "Missing mid price"
+
+        denom = liq_px - entry_px
+        frac = (mid_px - entry_px) / denom if denom != 0 else 0.0
+
+        if frac >= self.LIQUIDATION_REBALANCE_THRESHOLD:
+            return (
+                True,
+                f"mid=${mid_px:.4f} is {frac:.2%} of the way from entry=${entry_px:.4f} to liq=${liq_px:.4f}",
+            )
+
+        return (
+            False,
+            f"mid=${mid_px:.4f} is {frac:.2%} of the way from entry=${entry_px:.4f} to liq=${liq_px:.4f}",
+        )
+
     async def _verify_leg_balance(self, state: dict[str, Any]) -> tuple[bool, str]:
         """
         Verify that spot and perp legs are balanced (delta neutral).
@@ -2040,7 +2174,7 @@ class BasisTradingStrategy(BasisSnapshotMixin, Strategy):
         """
         Check if current delta-neutral position needs rebalancing.
 
-        Implements 7 health checks from Django hyperliquid_adapter.py:
+        Implements the following health checks:
         1. Missing positions
         2. Asset mismatch (if best specified)
         3. Funding accumulation threshold
@@ -2146,74 +2280,6 @@ class BasisTradingStrategy(BasisSnapshotMixin, Strategy):
 
         return 0.0
 
-    def _calculate_unused_usd(
-        self, state: dict[str, Any], deposited_amount: float
-    ) -> float:
-        """Calculate unused USD not deployed in positions."""
-        # Get account value
-        margin_summary = state.get("marginSummary", {})
-        account_value = float(margin_summary.get("accountValue", 0))
-
-        # Get total position value
-        total_ntl = float(margin_summary.get("totalNtlPos", 0))
-
-        # Unused = account value - position value
-        # For basis trading, we want most capital deployed
-        unused = account_value - abs(total_ntl)
-        return max(0.0, unused)
-
-    async def _validate_stop_loss_orders(
-        self,
-        state: dict[str, Any],
-        perp_position: dict[str, Any],
-    ) -> tuple[bool, str]:
-        """Validate stop-loss orders exist and are below liquidation price."""
-        address = self._get_strategy_wallet_address()
-
-        # Get liquidation price from perp position
-        liquidation_price = perp_position.get("liquidationPx")
-        if liquidation_price is None:
-            return False, "No liquidation price found"
-        liquidation_price = float(liquidation_price)
-
-        # Get open orders
-        success, open_orders = await self.hyperliquid_adapter.get_open_orders(address)
-        if not success:
-            return False, "Failed to fetch open orders"
-
-        perp_asset_id = perp_position.get("asset_id")
-
-        # Find stop-loss orders for perp
-        perp_sl_order = None
-
-        for order in open_orders:
-            order_type = order.get("orderType", "")
-            if "trigger" not in str(order_type).lower():
-                continue
-
-            asset = order.get("coin") or order.get("asset")
-            coin_match = (
-                asset == self.current_position.coin if self.current_position else False
-            )
-
-            if coin_match or order.get("asset_id") == perp_asset_id:
-                perp_sl_order = order
-                break
-
-        # Validate perp stop-loss exists
-        if perp_sl_order is None:
-            return False, "Missing perp stop-loss order"
-
-        # Validate price is below liquidation (for short, SL triggers on price RISE)
-        perp_sl_price = float(perp_sl_order.get("triggerPx", 0))
-        if perp_sl_price >= liquidation_price:
-            return (
-                False,
-                f"Perp stop-loss {perp_sl_price} >= liquidation {liquidation_price}",
-            )
-
-        return True, "Stop-loss orders valid"
-
     async def _place_stop_loss_orders(
         self,
         coin: str,
@@ -2515,132 +2581,9 @@ class BasisTradingStrategy(BasisSnapshotMixin, Strategy):
         return total_value, hl_value, strategy_wallet_value
 
     # ------------------------------------------------------------------ #
-    # Analysis Methods (ported from BasisTradingService)                  #
+    # Analysis Methods                                                    #
     # ------------------------------------------------------------------ #
 
-    async def find_best_basis_trades(
-        self,
-        deposit_usdc: float,
-        lookback_days: int = 180,
-        confidence: float = 0.975,
-        fee_eps: float = 0.003,
-        oi_floor: float = 50.0,
-        day_vlm_floor: float = 1e5,
-        horizons_days: list[int] | None = None,
-        max_leverage: int = 3,
-    ) -> list[dict[str, Any]]:
-        """
-        Find optimal basis trading opportunities.
-
-        Args:
-            deposit_usdc: Total deposit amount in USDC
-            lookback_days: Days of historical data to analyze
-            confidence: VaR confidence level (default 97.5%)
-            fee_eps: Fee buffer as fraction of notional
-            oi_floor: Minimum open interest threshold in USD
-            day_vlm_floor: Minimum daily volume threshold in USD
-            horizons_days: Time horizons for risk calculation
-            max_leverage: Maximum leverage allowed
-
-        Returns:
-            List of basis trade opportunities sorted by expected APY
-        """
-        if horizons_days is None:
-            horizons_days = [1, 7]
-
-        # Validate lookback doesn't exceed HL's 5000 candle limit
-        max_hours = 5000
-        max_days = max_hours // 24
-        if lookback_days > max_days:
-            self.logger.warning(
-                f"Lookback {lookback_days}d exceeds limit. Capping at {max_days}d"
-            )
-            lookback_days = max_days
-
-        try:
-            # Get perpetual market data
-            (
-                success,
-                perps_ctx_pack,
-            ) = await self.hyperliquid_adapter.get_meta_and_asset_ctxs()
-            if not success:
-                raise ValueError(f"Failed to fetch perp metadata: {perps_ctx_pack}")
-
-            perps_meta_list = perps_ctx_pack[0]["universe"]
-            perps_ctxs = perps_ctx_pack[1]
-
-            coin_to_ctx: dict[str, Any] = {}
-            coin_to_maxlev: dict[str, int] = {}
-            coin_to_margin_table: dict[str, int | None] = {}
-            coins: list[str] = []
-
-            for meta, ctx in zip(perps_meta_list, perps_ctxs, strict=False):
-                coin = meta["name"]
-                coin_to_ctx[coin] = ctx
-                coin_to_maxlev[coin] = int(meta.get("maxLeverage", 10))
-                coin_to_margin_table[coin] = meta.get("marginTableId")
-                coins.append(coin)
-
-            perps_set = set(coins)
-
-            # Get spot market data
-            success, spot_meta = await self.hyperliquid_adapter.get_spot_meta()
-            if not success:
-                raise ValueError(f"Failed to fetch spot metadata: {spot_meta}")
-
-            tokens = spot_meta.get("tokens", [])
-            spot_pairs = spot_meta.get("universe", [])
-            idx_to_token = {t["index"]: t["name"] for t in tokens}
-
-            # Find candidate basis pairs
-            candidates = self._find_basis_candidates(
-                spot_pairs, idx_to_token, perps_set
-            )
-            self.logger.info(f"Found {len(candidates)} spot-perp candidate pairs")
-
-            # Get perp asset ID mapping
-            perp_coin_to_asset_id = {
-                k: v
-                for k, v in self.hyperliquid_adapter.coin_to_asset.items()
-                if v < 10000
-            }
-
-            # Filter by liquidity
-            liquid = await self._filter_by_liquidity(
-                candidates=candidates,
-                coin_to_ctx=coin_to_ctx,
-                coin_to_maxlev=coin_to_maxlev,
-                coin_to_margin_table=coin_to_margin_table,
-                deposit_usdc=deposit_usdc,
-                max_leverage=max_leverage,
-                oi_floor=oi_floor,
-                day_vlm_floor=day_vlm_floor,
-                perp_coin_to_asset_id=perp_coin_to_asset_id,
-            )
-            self.logger.info(
-                f"After liquidity filter: {len(liquid)} candidates "
-                f"(OI >= ${oi_floor}, volume >= ${day_vlm_floor:,.0f})"
-            )
-
-            # Analyze each candidate
-            results = await self._analyze_candidates(
-                liquid,
-                deposit_usdc,
-                lookback_days,
-                confidence,
-                fee_eps,
-                horizons_days,
-            )
-            self.logger.info(f"After historical analysis: {len(results)} opportunities")
-
-            # Sort by expected APY
-            results.sort(key=self._get_safe_apy_key, reverse=True)
-            return results
-
-        except Exception as e:
-            self.logger.error(f"Error finding basis trades: {e}")
-            raise
-
     def _find_basis_candidates(
         self,
         spot_pairs: list[dict],
@@ -2775,249 +2718,6 @@ class BasisTradingStrategy(BasisSnapshotMixin, Strategy):
 
         return liquid
 
-    async def _analyze_candidates(
-        self,
-        candidates: list[BasisCandidate],
-        deposit_usdc: float,
-        lookback_days: int,
-        confidence: float,
-        fee_eps: float,
-        horizons_days: list[int],
-    ) -> list[dict[str, Any]]:
-        """Analyze each liquid candidate for basis trading metrics."""
-        ms_now = int(time.time() * 1000)
-        start_ms = ms_now - int(lookback_days * 24 * 3600 * 1000)
-        z = self._z_from_conf(confidence)
-
-        results: list[dict[str, Any]] = []
-
-        required_hours = lookback_days * 24
-        skipped_reasons: dict[str, list[str]] = {
-            "no_funding": [],
-            "no_candles": [],
-            "insufficient_funding": [],
-            "insufficient_candles": [],
-        }
-
-        for candidate in candidates:
-            coin = candidate.coin
-            spot_sym = candidate.spot_pair
-
-            # Fetch funding history with chunking for longer lookbacks
-            success, funding_data = await self._fetch_funding_history_chunked(
-                coin, start_ms, ms_now
-            )
-            if not success or not funding_data:
-                skipped_reasons["no_funding"].append(coin)
-                continue
-
-            hourly_funding = [float(x.get("fundingRate", 0.0)) for x in funding_data]
-
-            # Fetch candle data with chunking for longer lookbacks
-            success, candle_data = await self._fetch_candles_chunked(
-                coin, "1h", start_ms, ms_now
-            )
-            if not success or not candle_data:
-                skipped_reasons["no_candles"].append(coin)
-                continue
-
-            closes = [float(c.get("c", 0)) for c in candle_data if c.get("c")]
-            highs = [float(c.get("h", 0)) for c in candle_data if c.get("h")]
-
-            # Require at least 7 days of data minimum, or 50% of lookback for longer periods
-            min_required = max(7 * 24, required_hours // 2)
-            if len(hourly_funding) < min_required:
-                skipped_reasons["insufficient_funding"].append(
-                    f"{coin}({len(hourly_funding)}/{min_required})"
-                )
-                continue
-            if len(closes) < min_required or len(highs) < min_required:
-                skipped_reasons["insufficient_candles"].append(
-                    f"{coin}(closes={len(closes)},highs={len(highs)}/{min_required})"
-                )
-                continue
-
-            # Calculate price volatility
-            sigma_hourly = (
-                pstdev(
-                    [(closes[i] / closes[i - 1] - 1.0) for i in range(1, len(closes))]
-                )
-                if len(closes) > 1
-                else 0.005
-            )
-
-            # Calculate funding statistics
-            funding_stats = self._calculate_funding_stats(hourly_funding)
-
-            # Calculate safe leverages
-            max_lev = candidate.target_leverage
-            m_maint = self.maintenance_rate_from_max_leverage(max_lev)
-
-            safe = self._calculate_safe_leverages(
-                hourly_funding=hourly_funding,
-                closes=closes,
-                highs=highs,
-                z=z,
-                m_maint=m_maint,
-                fee_eps=fee_eps,
-                max_lev=max_lev,
-                deposit_usdc=deposit_usdc,
-                horizons_days=horizons_days,
-            )
-
-            result = {
-                "coin": coin,
-                "spot_pair": spot_sym,
-                "spot_asset_id": candidate.spot_asset_id,
-                "perp_asset_id": candidate.perp_asset_id,
-                "maxLeverage": max_lev,
-                "maintenance_rate_est": m_maint,
-                "openInterest": candidate.open_interest_base,
-                "day_notional_volume": candidate.day_notional_usd,
-                "funding_stats": funding_stats,
-                "price_stats": {
-                    "sigma_hourly": sigma_hourly,
-                    "z_for_confidence": z,
-                    "confidence": confidence,
-                },
-                "safe": safe,
-                "depth_checks": candidate.depth_checks,
-            }
-
-            results.append(result)
-
-        # Log skip reasons
-        for reason, coins in skipped_reasons.items():
-            if coins:
-                self.logger.debug(
-                    f"Skipped ({reason}): {', '.join(coins[:5])}{'...' if len(coins) > 5 else ''}"
-                )
-
-        return results
-
-    def _calculate_funding_stats(self, hourly_funding: list[float]) -> dict[str, Any]:
-        """Calculate comprehensive funding rate statistics."""
-        if not hourly_funding:
-            return {
-                "mean_hourly": 0.0,
-                "neg_hour_fraction": 0.0,
-                "hourly_vol": 0.0,
-                "worst_24h_sum": 0.0,
-                "worst_7d_sum": 0.0,
-                "points": 0,
-            }
-
-        mean_hourly = mean(hourly_funding)
-        neg_hour_frac = sum(1 for r in hourly_funding if r < 0.0) / len(hourly_funding)
-        hourly_vol = pstdev(hourly_funding) if len(hourly_funding) > 1 else 0.0
-        worst_24h = self._rolling_min_sum(hourly_funding, 24)
-        worst_7d = self._rolling_min_sum(hourly_funding, 24 * 7)
-
-        return {
-            "mean_hourly": mean_hourly,
-            "neg_hour_fraction": neg_hour_frac,
-            "hourly_vol": hourly_vol,
-            "worst_24h_sum": worst_24h,
-            "worst_7d_sum": worst_7d,
-            "points": len(hourly_funding),
-        }
-
-    def _calculate_safe_leverages(
-        self,
-        hourly_funding: list[float],
-        closes: list[float],
-        highs: list[float],
-        z: float,
-        m_maint: float,
-        fee_eps: float,
-        max_lev: int,
-        deposit_usdc: float,
-        horizons_days: list[int],
-    ) -> dict[str, Any]:
-        """Calculate safe leverage for each time horizon."""
-        results: dict[str, Any] = {}
-
-        for horizon in horizons_days:
-            window = horizon * 24
-            b_star = self._worst_buffer_requirement(
-                closes, highs, hourly_funding, window, m_maint, fee_eps
-            )
-
-            if b_star >= 1.0:
-                results[f"{horizon}d"] = {
-                    "pass": False,
-                    "leverage": 0,
-                    "reason": "Buffer requirement exceeds 100%",
-                }
-                continue
-
-            safe_lev = min(max_lev, int(1.0 / b_star)) if b_star > 0 else max_lev
-
-            # Calculate expected APY
-            mean_funding = mean(hourly_funding) if hourly_funding else 0
-            expected_apy = mean_funding * 24 * 365 * safe_lev
-
-            # Estimate quantities
-            order_usd = deposit_usdc * (safe_lev / (safe_lev + 1))
-            avg_price = mean(closes) if closes else 1.0
-            qty = order_usd / avg_price if avg_price > 0 else 0
-
-            results[f"{horizon}d"] = {
-                "pass": True,
-                "leverage": safe_lev,
-                "buffer_requirement": b_star,
-                "expected_apy_pct": expected_apy,
-                "spot_qty": qty,
-                "perp_qty": qty,
-                "order_usd": order_usd,
-            }
-
-        return results
-
-    def _worst_buffer_requirement(
-        self,
-        closes: list[float],
-        highs: list[float],
-        hourly_funding: list[float],
-        window: int,
-        mmr: float,
-        fee_eps: float,
-    ) -> float:
-        """
-        Calculate worst-case buffer requirement over rolling windows.
-
-        Uses deterministic historical "stress test" approach.
-        """
-        n = min(len(closes), len(highs), len(hourly_funding))
-        if n < window or n == 0:
-            return 1.0
-
-        worst_req = 0.0
-
-        for start in range(n - window + 1):
-            end = start + window
-            entry_price = closes[start]
-            if entry_price <= 0:
-                continue
-
-            cum_f = 0.0
-            runup = 0.0
-
-            for i in range(start, end):
-                peak = highs[i]
-                step_runup = (peak / entry_price - 1.0) if entry_price > 0 else 0.0
-                runup = max(runup, step_runup)
-
-                r = hourly_funding[i] if i < len(hourly_funding) else 0.0
-                if r < 0.0:
-                    cum_f += (-r) * (1.0 + runup)
-
-                req = mmr * (1.0 + runup) + runup + cum_f + fee_eps
-                if req > worst_req:
-                    worst_req = req
-
-        return worst_req
-
     # ------------------------------------------------------------------ #
     # Chunked Data Fetching                                               #
     # ------------------------------------------------------------------ #
@@ -3177,7 +2877,7 @@ class BasisTradingStrategy(BasisSnapshotMixin, Strategy):
         return True, all_candles
 
     # ------------------------------------------------------------------ #
-    # Net APY Solver + Bootstrap (ported from Django NetApyBasisTradingService)
+    # Net APY Solver + Bootstrap                                          #
     # ------------------------------------------------------------------ #
 
     def _spot_index_from_asset_id(self, spot_asset_id: int) -> int:
@@ -3904,16 +3604,6 @@ class BasisTradingStrategy(BasisSnapshotMixin, Strategy):
 
         return worst_req if worst_req > 0 else float(fallback_mmr + fee_eps)
 
-    def get_sz_decimals_for_hypecore_asset(self, asset_id: int) -> int:
-        try:
-            mapping = self.hyperliquid_adapter.asset_to_sz_decimals
-        except Exception as exc:  # noqa: BLE001
-            raise ValueError("Hyperliquid asset_to_sz_decimals not available") from exc
-
-        if not isinstance(mapping, dict):
-            raise ValueError(f"Unknown asset_id {asset_id}: missing szDecimals")
-        return hl_sz_decimals_for_asset(mapping, asset_id)
-
     def _size_step(self, asset_id: int) -> Decimal:
         try:
             mapping = self.hyperliquid_adapter.asset_to_sz_decimals
@@ -4441,15 +4131,6 @@ class BasisTradingStrategy(BasisSnapshotMixin, Strategy):
             return 0.5
         return 0.5 / max_lev
 
-    @staticmethod
-    def _get_safe_apy_key(result: dict[str, Any]) -> float:
-        """Sort key for results by 7d expected APY."""
-        safe = result.get("safe", {})
-        safe_7d = safe.get("7d", {})
-        if not safe_7d.get("pass", False):
-            return -999.0
-        return safe_7d.get("expected_apy_pct", 0.0)
-
     def _get_strategy_wallet_address(self) -> str:
         """Get strategy wallet address from config."""
         strategy_wallet = self.config.get("strategy_wallet")