wayfinder-paths 0.1.19__py3-none-any.whl → 0.1.21__py3-none-any.whl

wayfinder_paths/strategies/basis_trading_strategy/strategy.py

@@ -1,10 +1,3 @@
-"""
-BasisTradingStrategy - Delta-neutral basis trading on Hyperliquid.
-
-Identifies and executes basis trading opportunities by pairing spot long
-positions with perpetual short positions to capture funding rate payments.
-"""
-
 from __future__ import annotations
 
 import asyncio
@@ -81,34 +74,24 @@ from wayfinder_paths.strategies.basis_trading_strategy.types import (
     BasisPosition,
 )
 
-# Set decimal precision for precise price/size calculations
 getcontext().prec = 28
 
 
 def _d(x: float | Decimal | str) -> Decimal:
-    """Convert to Decimal for precise calculations."""
     return x if isinstance(x, Decimal) else Decimal(str(x))
 
 
 class BasisTradingStrategy(BasisSnapshotMixin, Strategy):
-    """
-    Delta-neutral basis trading strategy on Hyperliquid.
-
-    Captures funding rate payments by maintaining offsetting spot long and
-    perpetual short positions. Uses historical funding rate and volatility
-    analysis to select optimal opportunities.
-    """
-
     name = "Basis Trading Strategy"
 
     # Strategy parameters
     MIN_DEPOSIT_USDC = 25
-    DEFAULT_LOOKBACK_DAYS = 30  # Supports up to ~208 days via chunked API calls
-    DEFAULT_FEE_EPS = 0.003  # 0.3% fee buffer
-    DEFAULT_OI_FLOOR = 100_000.0  # Min OI in USD
-    DEFAULT_DAY_VLM_FLOOR = 100_000  # Min daily volume
+    DEFAULT_LOOKBACK_DAYS = 30
+    DEFAULT_FEE_EPS = 0.003
+    DEFAULT_OI_FLOOR = 100_000.0
+    DEFAULT_DAY_VLM_FLOOR = 100_000
     DEFAULT_MAX_LEVERAGE = 2
-    GAS_MAXIMUM = 0.01  # ETH
+    GAS_MAXIMUM = 0.01
     DEFAULT_BOOTSTRAP_SIMS = 50
     DEFAULT_BOOTSTRAP_BLOCK_HOURS = 48
 
@@ -117,19 +100,18 @@ class BasisTradingStrategy(BasisSnapshotMixin, Strategy):
     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
+    FUNDING_REBALANCE_THRESHOLD = 0.02
 
     # 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
+    SPOT_POSITION_DUST_TOLERANCE = 0.04
+    MIN_UNUSED_USD = 5.0
+    UNUSED_REL_EPS = 0.01
 
     # Rotation cooldown
-    ROTATION_MIN_INTERVAL_DAYS = 14  # 14 days between rotations
+    ROTATION_MIN_INTERVAL_DAYS = 14
 
-    # Builder fee for Hyperliquid trades
     HYPE_FEE_WALLET: str = "0xaA1D89f333857eD78F8434CC4f896A9293EFE65c"
-    HYPE_PRO_FEE: int = 30  # in tenths of basis points (0.03% = 3 bps)
+    HYPE_PRO_FEE: int = 30
     DEFAULT_BUILDER_FEE: dict[str, Any] = {"b": HYPE_FEE_WALLET, "f": HYPE_PRO_FEE}
 
     INFO = StratDescriptor(
@@ -223,8 +205,6 @@ class BasisTradingStrategy(BasisSnapshotMixin, Strategy):
         self.current_position: BasisPosition | None = None
         self.deposit_amount: float = 0.0
 
-        # Builder fee for Hyperliquid trades (from config or default)
-        # Format: {"b": "0x...", "f": 10}  where 'b' is address, 'f' is fee in bps
         self.builder_fee: dict[str, Any] | None = self.config.get(
             "builder_fee", self.DEFAULT_BUILDER_FEE
         )
@@ -243,7 +223,6 @@ class BasisTradingStrategy(BasisSnapshotMixin, Strategy):
             "strategy": self.config,
         }
 
-        # Create Hyperliquid executor if not provided.
         # This is only required for placing/canceling orders (not market reads).
         hl_executor = hyperliquid_executor
         if hl_executor is None:
@@ -291,13 +270,11 @@ class BasisTradingStrategy(BasisSnapshotMixin, Strategy):
             self.register_adapters(adapters)
 
     async def setup(self) -> None:
-        """Initialize strategy state from chain/ledger and discover existing positions."""
         self.logger.info("Starting BasisTradingStrategy setup")
         start_time = time.time()
 
         await super().setup()
 
-        # Get net deposit from ledger
         try:
             success, deposit_data = await self.ledger_adapter.get_strategy_net_deposit(
                 wallet_address=self._get_strategy_wallet_address()
@@ -317,15 +294,8 @@ class BasisTradingStrategy(BasisSnapshotMixin, Strategy):
         self.logger.info(f"BasisTradingStrategy setup completed in {elapsed:.2f}s")
 
     async def _discover_existing_position(self) -> None:
-        """
-        Discover existing delta-neutral position from Hyperliquid state.
-
-        This is critical for restart recovery - we must not open new positions
-        if one already exists on-chain.
-        """
         address = self._get_strategy_wallet_address()
 
-        # Get perp positions
         success, user_state = await self.hyperliquid_adapter.get_user_state(address)
         if not success:
             self.logger.warning("Could not fetch user state for position discovery")
@@ -341,7 +311,7 @@ class BasisTradingStrategy(BasisSnapshotMixin, Strategy):
         for pos_wrapper in asset_positions:
             pos = pos_wrapper.get("position", {})
             szi = float(pos.get("szi", 0))
-            if szi < 0:  # Short position
+            if szi < 0:
                 perp_position = pos
                 break
 
@@ -353,7 +323,6 @@ class BasisTradingStrategy(BasisSnapshotMixin, Strategy):
         perp_size = abs(float(perp_position.get("szi", 0)))
         entry_px = float(perp_position.get("entryPx", 0))
 
-        # Get spot positions to find matching spot leg
         success, spot_state = await self.hyperliquid_adapter.get_spot_user_state(
             address
         )
@@ -389,7 +358,6 @@ class BasisTradingStrategy(BasisSnapshotMixin, Strategy):
         else:
             spot_size = float(spot_position.get("total", 0))
 
-        # Get asset IDs
         perp_asset_id = self.hyperliquid_adapter.coin_to_asset.get(coin)
         # Spot asset ID: look up from spot meta or estimate
         spot_asset_id = None
@@ -401,7 +369,6 @@ class BasisTradingStrategy(BasisSnapshotMixin, Strategy):
                 base_idx = pair["tokens"][0]
                 for t in tokens:
                     if t["index"] == base_idx:
-                        # Check if this token matches our coin
                         if (
                             t["name"] == coin
                             or t["name"] == f"U{coin}"
@@ -420,14 +387,13 @@ class BasisTradingStrategy(BasisSnapshotMixin, Strategy):
             spot_amount=spot_size,
             perp_amount=perp_size,
             entry_price=entry_px,
-            leverage=2,  # Default, actual leverage can be inferred
-            entry_timestamp=int(time.time() * 1000),  # Approximate
+            leverage=2,
+            entry_timestamp=int(time.time() * 1000),
             funding_collected=abs(
                 float(perp_position.get("cumFunding", {}).get("sinceOpen", 0))
             ),
         )
 
-        # Update deposit amount from actual account value if not set
         if self.deposit_amount <= 0:
             margin_summary = user_state.get("marginSummary", {})
             self.deposit_amount = float(margin_summary.get("accountValue", 0))
@@ -442,19 +408,6 @@ class BasisTradingStrategy(BasisSnapshotMixin, Strategy):
         main_token_amount: float = 0.0,
         gas_token_amount: float = 0.0,
     ) -> StatusTuple:
-        """
-        Deposit USDC to Hyperliquid L1 for basis trading.
-
-        Sends USDC from the strategy wallet to the Hyperliquid bridge address on Arbitrum,
-        then waits for it to be credited on Hyperliquid L1.
-
-        Args:
-            main_token_amount: Amount of USDC to deposit
-            gas_token_amount: Amount of ETH for gas (unused, kept for interface compatibility)
-
-        Returns:
-            StatusTuple (success, message)
-        """
         if main_token_amount < self.MIN_DEPOSIT_USDC:
             return (False, f"Minimum deposit is {self.MIN_DEPOSIT_USDC} USDC")
 
@@ -475,7 +428,7 @@ class BasisTradingStrategy(BasisSnapshotMixin, Strategy):
                 gas_ok,
                 gas_res,
             ) = await self.balance_adapter.move_from_main_wallet_to_strategy_wallet(
-                token_id="ethereum-arbitrum",  # Native ETH on Arbitrum
+                token_id="ethereum-arbitrum",
                 amount=gas_token_amount,
                 strategy_name=self.name or "basis_trading_strategy",
             )
@@ -489,7 +442,6 @@ class BasisTradingStrategy(BasisSnapshotMixin, Strategy):
             main_address = self._get_main_wallet_address()
             strategy_address = self._get_strategy_wallet_address()
 
-            # Check if strategy wallet already has sufficient USDC
             (
                 strategy_balance_ok,
                 strategy_balance,
@@ -544,24 +496,9 @@ class BasisTradingStrategy(BasisSnapshotMixin, Strategy):
             return (False, f"Deposit failed: {e}")
 
     async def update(self) -> StatusTuple:
-        """
-        Analyze markets and manage positions.
-
-        - If no position exists, analyzes opportunities and opens the best one.
-        - If position exists, monitors and maintains it:
-          - Checks for rebalance conditions
-          - Verifies leg balance (spot == perp)
-          - Deploys any idle capital
-          - Ensures stop-loss orders are valid
-
-        Returns:
-            StatusTuple (success, message)
-        """
-        # 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:
             (
@@ -576,7 +513,6 @@ class BasisTradingStrategy(BasisSnapshotMixin, Strategy):
         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()
@@ -584,7 +520,6 @@ class BasisTradingStrategy(BasisSnapshotMixin, Strategy):
         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)
@@ -599,7 +534,6 @@ class BasisTradingStrategy(BasisSnapshotMixin, Strategy):
                     f"Found ${strategy_usdc:.2f} USDC in strategy wallet, bridging to Hyperliquid"
                 )
 
-                # 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,
@@ -622,7 +556,7 @@ class BasisTradingStrategy(BasisSnapshotMixin, Strategy):
                 ) = await self.hyperliquid_adapter.wait_for_deposit(
                     address=strategy_address,
                     expected_increase=strategy_usdc,
-                    timeout_s=180,  # 3 minutes
+                    timeout_s=180,
                     poll_interval_s=10,
                 )
 
@@ -654,19 +588,6 @@ class BasisTradingStrategy(BasisSnapshotMixin, Strategy):
     async def analyze(
         self, deposit_usdc: float = 1000.0, verbose: bool = True
     ) -> dict[str, Any]:
-        """
-        Analyze basis trading opportunities without executing.
-
-        Uses the Net-APY + stop-churn backtest solver with block-bootstrap
-        resampling.
-
-        Args:
-            deposit_usdc: Hypothetical deposit amount for sizing calculations (default $1000)
-            verbose: Include debug info about filtering
-
-        Returns:
-            Dict with opportunities sorted by net APY (includes bootstrap metrics)
-        """
         self.logger.info(
             f"Analyzing basis opportunities for ${deposit_usdc} deposit..."
         )
@@ -718,7 +639,6 @@ class BasisTradingStrategy(BasisSnapshotMixin, Strategy):
                         "Falling back to live analysis."
                     )
 
-            # Get market data for debug info
             (
                 success,
                 perps_ctx_pack,
@@ -793,12 +713,6 @@ class BasisTradingStrategy(BasisSnapshotMixin, Strategy):
             }
 
     def _cfg_get(self, key: str, default: Any | None = None) -> Any:
-        """
-        Read a strategy config value.
-
-        Supports both flat configs (common in this repo) and nested configs
-        where strategy settings live under a "strategy" key.
-        """
         if key in self.config:
             return self.config.get(key, default)
         nested = self.config.get("strategy")
@@ -807,11 +721,6 @@ class BasisTradingStrategy(BasisSnapshotMixin, Strategy):
         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]
@@ -828,7 +737,6 @@ class BasisTradingStrategy(BasisSnapshotMixin, Strategy):
                 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:
@@ -837,7 +745,6 @@ class BasisTradingStrategy(BasisSnapshotMixin, Strategy):
         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
@@ -846,25 +753,9 @@ class BasisTradingStrategy(BasisSnapshotMixin, Strategy):
         return c1 == c2
 
     async def withdraw(self, amount: float | None = None) -> StatusTuple:
-        """
-        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)
-
-        Returns:
-            StatusTuple (success, message)
-        """
         address = self._get_strategy_wallet_address()
         usdc_token_id = "usd-coin-arbitrum"
 
-        # Check for USDC already in strategy wallet on Arbitrum
         strategy_usdc = 0.0
         try:
             success, balance_data = await self.balance_adapter.get_balance(
@@ -872,11 +763,10 @@ class BasisTradingStrategy(BasisSnapshotMixin, Strategy):
                 wallet_address=address,
             )
             if success:
-                strategy_usdc = float(balance_data) / 1e6  # USDC has 6 decimals
+                strategy_usdc = float(balance_data) / 1e6
         except Exception as e:
             self.logger.warning(f"Could not get strategy wallet balance: {e}")
 
-        # Get current Hyperliquid value (perp + spot)
         hl_perp_value = 0.0
         hl_spot_usdc = 0.0
         success, user_state = await self.hyperliquid_adapter.get_user_state(address)
@@ -896,7 +786,6 @@ class BasisTradingStrategy(BasisSnapshotMixin, Strategy):
 
         hl_value = hl_perp_value + hl_spot_usdc
 
-        # Check if there's anything to withdraw
         if strategy_usdc < 1.0 and hl_value < 1.0 and self.current_position is None:
             return (False, "Nothing to withdraw")
 
@@ -937,7 +826,7 @@ class BasisTradingStrategy(BasisSnapshotMixin, Strategy):
                     # 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
+                    if spot_usdc > 1.0:
                         self.logger.info(
                             f"Transferring ${spot_usdc:.2f} from spot to perp "
                             f"(available={available:.8f}, floored={spot_usdc:.2f})"
@@ -1009,7 +898,7 @@ class BasisTradingStrategy(BasisSnapshotMixin, Strategy):
         ) = await self.hyperliquid_adapter.wait_for_withdrawal(
             address=address,
             lookback_s=5,
-            max_poll_time_s=20 * 60,  # 20 minutes max
+            max_poll_time_s=20 * 60,
             poll_interval_s=10,
         )
 
@@ -1020,7 +909,6 @@ class BasisTradingStrategy(BasisSnapshotMixin, Strategy):
                 "Check Hyperliquid explorer for status.",
             )
 
-        # Get the withdrawal amount from the most recent tx
         tx_hash = list(withdrawals.keys())[-1]
         withdrawn_amount = withdrawals[tx_hash]
         self.logger.info(
@@ -1030,7 +918,6 @@ class BasisTradingStrategy(BasisSnapshotMixin, Strategy):
         # Step 5: Wait a bit for the USDC to be credited on Arbitrum
         await asyncio.sleep(10)
 
-        # Get final USDC balance in strategy wallet
         final_balance = 0.0
         try:
             success, balance_data = await self.balance_adapter.get_balance(
@@ -1038,7 +925,7 @@ class BasisTradingStrategy(BasisSnapshotMixin, Strategy):
                 wallet_address=address,
             )
             if success:
-                final_balance = float(balance_data) / 1e6  # USDC has 6 decimals
+                final_balance = float(balance_data) / 1e6
         except Exception as e:
             self.logger.warning(f"Could not get final balance: {e}")
 
@@ -1052,7 +939,6 @@ class BasisTradingStrategy(BasisSnapshotMixin, Strategy):
         )
 
     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()
@@ -1119,7 +1005,6 @@ class BasisTradingStrategy(BasisSnapshotMixin, Strategy):
         return (True, f"Transferred to main wallet: {', '.join(transferred_items)}")
 
     async def _status(self) -> StatusDict:
-        """Return portfolio value and strategy status with live data."""
         total_value, hl_value, vault_value = await self._get_total_portfolio_value()
 
         status_payload: dict[str, Any] = {
@@ -1140,7 +1025,6 @@ class BasisTradingStrategy(BasisSnapshotMixin, Strategy):
                 }
             )
 
-        # Get net deposit from ledger
         try:
             success, deposit_data = await self.ledger_adapter.get_strategy_net_deposit(
                 wallet_address=self._get_strategy_wallet_address()
@@ -1163,20 +1047,10 @@ class BasisTradingStrategy(BasisSnapshotMixin, Strategy):
 
     @staticmethod
     async def policies() -> list[str]:
-        """Return wallet permission policies."""
         # Placeholder - would include Hyperliquid-specific policies
         return []
 
     async def ensure_builder_fee_approved(self) -> StatusTuple:
-        """
-        Ensure the builder fee is approved before trading.
-
-        Checks the current max builder fee approval for the user/builder pair.
-        If the current approval is less than required, submits an approval transaction.
-
-        Returns:
-            StatusTuple (success, message)
-        """
         if not self.builder_fee:
             return True, "No builder fee configured"
 
@@ -1188,7 +1062,6 @@ class BasisTradingStrategy(BasisSnapshotMixin, Strategy):
             return True, "Builder fee not required"
 
         try:
-            # Check current approval
             success, current_fee = await self.hyperliquid_adapter.get_max_builder_fee(
                 user=address,
                 builder=builder,
@@ -1208,7 +1081,6 @@ class BasisTradingStrategy(BasisSnapshotMixin, Strategy):
                 return True, f"Builder fee already approved: {current_fee}"
 
             # Need to approve
-            # Convert fee to percentage string (e.g., 30 tenths bp = 0.030%)
             max_fee_rate = f"{required_fee / 1000:.3f}%"
             self.logger.info(
                 f"Approving builder fee: builder={builder}, rate={max_fee_rate}"
@@ -1236,7 +1108,6 @@ class BasisTradingStrategy(BasisSnapshotMixin, Strategy):
     # ------------------------------------------------------------------ #
 
     async def _find_and_open_position(self) -> StatusTuple:
-        """Analyze markets and open the best basis position."""
         self.logger.info("Analyzing basis trading opportunities...")
 
         try:
@@ -1430,7 +1301,6 @@ class BasisTradingStrategy(BasisSnapshotMixin, Strategy):
                 f"notional=${spot_notional:.2f}/${perp_notional:.2f}"
             )
 
-            # Get entry price from current mid
             success, mids = await self.hyperliquid_adapter.get_all_mid_prices()
             entry_price = self._resolve_mid_price(coin, mids) if success else 0.0
 
@@ -1459,7 +1329,6 @@ class BasisTradingStrategy(BasisSnapshotMixin, Strategy):
             else:
                 self.logger.warning("Could not get liquidation price for stop-loss")
 
-            # Create position record
             self.current_position = BasisPosition(
                 coin=coin,
                 spot_asset_id=spot_asset_id,
@@ -1485,15 +1354,8 @@ class BasisTradingStrategy(BasisSnapshotMixin, Strategy):
     # ------------------------------------------------------------------ #
 
     async def _get_undeployed_capital(self) -> tuple[float, float]:
-        """
-        Calculate undeployed capital that can be added to the position.
-
-        Returns:
-            (perp_margin_available, spot_usdc_available)
-        """
         address = self._get_strategy_wallet_address()
 
-        # Get perp state
         success, user_state = await self.hyperliquid_adapter.get_user_state(address)
         if not success:
             return 0.0, 0.0
@@ -1508,7 +1370,6 @@ class BasisTradingStrategy(BasisSnapshotMixin, Strategy):
 
         withdrawable = float(withdrawable_val or 0.0)
 
-        # Get spot USDC balance
         success, spot_state = await self.hyperliquid_adapter.get_spot_user_state(
             address
         )
@@ -1527,13 +1388,6 @@ class BasisTradingStrategy(BasisSnapshotMixin, Strategy):
         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"
 
@@ -1592,32 +1446,17 @@ class BasisTradingStrategy(BasisSnapshotMixin, Strategy):
         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.
-
-        Uses PairedFiller to atomically add to both spot and perp legs,
-        maintaining delta neutrality.
-
-        Args:
-            additional_capital: USD amount of new capital to deploy
-
-        Returns:
-            StatusTuple (success, message)
-        """
         if self.current_position is None:
             return False, "No position to scale up"
 
         pos = self.current_position
         address = self._get_strategy_wallet_address()
 
-        # Get current leverage from position
         leverage = pos.leverage or 2
 
-        # Calculate how much to add to each leg
         # order_usd = capital * (L / (L + 1)) for leveraged position
         order_usd = additional_capital * (leverage / (leverage + 1))
 
-        # Get current price
         success, mids = await self.hyperliquid_adapter.get_all_mid_prices()
         if not success:
             return False, "Failed to get mid prices"
@@ -1626,14 +1465,12 @@ class BasisTradingStrategy(BasisSnapshotMixin, Strategy):
         if price <= 0:
             return False, f"Invalid price for {pos.coin}"
 
-        # Check minimum notional ($10 USD per side)
         if order_usd < MIN_NOTIONAL_USD:
             return (
                 True,
                 f"Additional capital ${order_usd:.2f} below minimum notional ${MIN_NOTIONAL_USD}",
             )
 
-        # Calculate units to add
         units_to_add = order_usd / price
 
         # Round to valid decimals for the assets
@@ -1685,7 +1522,7 @@ class BasisTradingStrategy(BasisSnapshotMixin, Strategy):
                 spot_asset_id=pos.spot_asset_id,
                 perp_asset_id=pos.perp_asset_id,
                 total_units=units_to_add,
-                direction="long_spot_short_perp",  # Buy spot, sell perp
+                direction="long_spot_short_perp",
                 builder_fee=self.builder_fee,
             )
         except Exception as e:
@@ -1695,16 +1532,15 @@ class BasisTradingStrategy(BasisSnapshotMixin, Strategy):
         if spot_filled <= 0 or perp_filled <= 0:
             return False, f"Failed to add to position on {pos.coin}"
 
-        # Update position tracking
         self.current_position = BasisPosition(
             coin=pos.coin,
             spot_asset_id=pos.spot_asset_id,
             perp_asset_id=pos.perp_asset_id,
             spot_amount=pos.spot_amount + spot_filled,
             perp_amount=pos.perp_amount + perp_filled,
-            entry_price=price,  # Use new price as weighted entry
+            entry_price=price,
             leverage=leverage,
-            entry_timestamp=pos.entry_timestamp,  # Keep original
+            entry_timestamp=pos.entry_timestamp,
             funding_collected=pos.funding_collected,
         )
 
@@ -1719,15 +1555,6 @@ class BasisTradingStrategy(BasisSnapshotMixin, Strategy):
         )
 
     async def _monitor_position(self) -> StatusTuple:
-        """
-        Monitor existing position for exit/rebalance conditions.
-
-        Checks:
-        1. Whether rebalance is needed (funding, liquidity, etc.)
-        2. Both legs are balanced (spot and perp amounts match)
-        3. No significant idle capital (deploy if found)
-        4. Stop-loss orders are in place and valid
-        """
         if self.current_position is None:
             return (True, "No position to monitor")
 
@@ -1736,12 +1563,10 @@ class BasisTradingStrategy(BasisSnapshotMixin, Strategy):
         address = self._get_strategy_wallet_address()
         actions_taken: list[str] = []
 
-        # Get current state
         success, state = await self.hyperliquid_adapter.get_user_state(address)
         if not success:
             return (False, f"Failed to fetch user state: {state}")
 
-        # Calculate deposited amount from current on-exchange value
         total_value, hl_value, _ = await self._get_total_portfolio_value()
 
         # ------------------------------------------------------------------ #
@@ -1761,12 +1586,10 @@ class BasisTradingStrategy(BasisSnapshotMixin, Strategy):
             return await self._find_and_open_position()
 
         # ------------------------------------------------------------------ #
-        # Check 1: Rebalance needed?                                          #
         # ------------------------------------------------------------------ #
         needs_rebalance, reason = await self._needs_new_position(state, hl_value)
 
         if needs_rebalance:
-            # Check rotation cooldown
             rotation_allowed, cooldown_reason = await self._is_rotation_allowed()
 
             if not rotation_allowed:
@@ -1788,7 +1611,6 @@ class BasisTradingStrategy(BasisSnapshotMixin, Strategy):
             return await self._find_and_open_position()
 
         # ------------------------------------------------------------------ #
-        # Check 2: Verify both legs are balanced                              #
         # ------------------------------------------------------------------ #
         leg_ok, leg_msg = await self._verify_leg_balance(state)
         if not leg_ok:
@@ -1801,7 +1623,6 @@ class BasisTradingStrategy(BasisSnapshotMixin, Strategy):
                 actions_taken.append(f"Leg imbalance repair failed: {repair_msg}")
 
         # ------------------------------------------------------------------ #
-        # Check 3: Deploy any idle capital                                    #
         # ------------------------------------------------------------------ #
         perp_margin, spot_usdc = await self._get_undeployed_capital()
         total_idle = perp_margin + spot_usdc
@@ -1822,7 +1643,6 @@ class BasisTradingStrategy(BasisSnapshotMixin, Strategy):
                 actions_taken.append(f"Scale-up failed: {scale_msg}")
 
         # ------------------------------------------------------------------ #
-        # Check 4: Verify stop-loss orders                                    #
         # ------------------------------------------------------------------ #
         sl_ok, sl_msg = await self._ensure_stop_loss_valid(state)
         if not sl_ok:
@@ -1844,12 +1664,6 @@ class BasisTradingStrategy(BasisSnapshotMixin, Strategy):
         )
 
     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"
 
@@ -1908,19 +1722,12 @@ class BasisTradingStrategy(BasisSnapshotMixin, Strategy):
         )
 
     async def _verify_leg_balance(self, state: dict[str, Any]) -> tuple[bool, str]:
-        """
-        Verify that spot and perp legs are balanced (delta neutral).
-
-        Returns:
-            (is_balanced, message)
-        """
         if self.current_position is None:
             return True, "No position"
 
         pos = self.current_position
         coin = pos.coin
 
-        # Get actual perp position size from state
         perp_size = 0.0
         for pos_wrapper in state.get("assetPositions", []):
             position = pos_wrapper.get("position", {})
@@ -1928,7 +1735,6 @@ class BasisTradingStrategy(BasisSnapshotMixin, Strategy):
                 perp_size = abs(float(position.get("szi", 0)))
                 break
 
-        # Get actual spot balance
         address = self._get_strategy_wallet_address()
         success, spot_state = await self.hyperliquid_adapter.get_spot_user_state(
             address
@@ -1940,20 +1746,18 @@ class BasisTradingStrategy(BasisSnapshotMixin, Strategy):
                     spot_size = float(bal.get("total", 0))
                     break
 
-        # Check balance - allow 2% tolerance
         if spot_size <= 0 and perp_size <= 0:
             return False, "Both legs are zero"
 
         max_size = max(spot_size, perp_size)
         if max_size > 0:
             imbalance_pct = abs(spot_size - perp_size) / max_size
-            if imbalance_pct > 0.02:  # 2% tolerance
+            if imbalance_pct > 0.02:
                 return (
                     False,
                     f"Imbalance: spot={spot_size:.6f}, perp={perp_size:.6f} ({imbalance_pct * 100:.1f}%)",
                 )
 
-        # Update tracked position with actual values
         self.current_position = BasisPosition(
             coin=pos.coin,
             spot_asset_id=pos.spot_asset_id,
@@ -1969,11 +1773,6 @@ class BasisTradingStrategy(BasisSnapshotMixin, Strategy):
         return True, f"Balanced: spot={spot_size:.6f}, perp={perp_size:.6f}"
 
     async def _repair_leg_imbalance(self, state: dict[str, Any]) -> tuple[bool, str]:
-        """
-        Attempt to repair an imbalance between spot and perp legs.
-
-        If one leg is larger, adds to the smaller leg to match.
-        """
         if self.current_position is None:
             return True, "No position"
 
@@ -1981,7 +1780,6 @@ class BasisTradingStrategy(BasisSnapshotMixin, Strategy):
         coin = pos.coin
         address = self._get_strategy_wallet_address()
 
-        # Get actual sizes
         perp_size = 0.0
         for pos_wrapper in state.get("assetPositions", []):
             position = pos_wrapper.get("position", {})
@@ -2003,7 +1801,6 @@ class BasisTradingStrategy(BasisSnapshotMixin, Strategy):
         if diff < 0.001:
             return True, "Legs already balanced"
 
-        # Get current price
         success, mids = await self.hyperliquid_adapter.get_all_mid_prices()
         if not success:
             return False, "Failed to get mid prices"
@@ -2012,7 +1809,7 @@ class BasisTradingStrategy(BasisSnapshotMixin, Strategy):
             return False, f"Invalid price for {coin}"
 
         diff_usd = diff * price
-        if diff_usd < 10:  # Below minimum notional
+        if diff_usd < 10:
             return True, f"Imbalance ${diff_usd:.2f} below minimum notional"
 
         try:
@@ -2054,24 +1851,12 @@ class BasisTradingStrategy(BasisSnapshotMixin, Strategy):
             return False, f"Repair failed: {e}"
 
     async def _ensure_stop_loss_valid(self, state: dict[str, Any]) -> tuple[bool, str]:
-        """
-        Ensure stop-loss orders are in place and valid for current position.
-
-        Checks:
-        - Stop-loss exists for the perp leg
-        - Trigger price is valid (below liquidation price)
-        - Size matches position size
-
-        Returns:
-            (success, message)
-        """
         if self.current_position is None:
             return True, "No position"
 
         pos = self.current_position
         coin = pos.coin
 
-        # Get current perp position and liquidation price
         perp_size = 0.0
         liquidation_price = None
         entry_price = pos.entry_price
@@ -2081,7 +1866,6 @@ class BasisTradingStrategy(BasisSnapshotMixin, Strategy):
             if position.get("coin") == coin:
                 perp_size = abs(float(position.get("szi", 0)))
                 liquidation_price = float(position.get("liquidationPx", 0))
-                # Update entry price from position if available
                 entry_px = position.get("entryPx")
                 if entry_px:
                     entry_price = float(entry_px)
@@ -2093,7 +1877,6 @@ class BasisTradingStrategy(BasisSnapshotMixin, Strategy):
         if not liquidation_price or liquidation_price <= 0:
             return False, "Could not determine liquidation price"
 
-        # Get spot position size from LIVE balance (not stored position)
         # to ensure stop-loss covers the actual spot holdings
         spot_position = await self._get_spot_position()
         if spot_position:
@@ -2101,7 +1884,6 @@ class BasisTradingStrategy(BasisSnapshotMixin, Strategy):
         else:
             spot_size = pos.spot_amount
 
-        # Call existing method which checks and places/updates if needed
         return await self._place_stop_loss_orders(
             coin=coin,
             perp_asset_id=pos.perp_asset_id,
@@ -2113,7 +1895,6 @@ class BasisTradingStrategy(BasisSnapshotMixin, Strategy):
         )
 
     async def _cancel_all_position_orders(self) -> None:
-        """Cancel all open orders (stop-loss, limit) for the current position."""
         if self.current_position is None:
             return
 
@@ -2123,7 +1904,6 @@ class BasisTradingStrategy(BasisSnapshotMixin, Strategy):
             f"@{pos.spot_asset_id - 10000}" if pos.spot_asset_id >= 10000 else None
         )
 
-        # Get all open orders including triggers
         success, open_orders = await self.hyperliquid_adapter.get_frontend_open_orders(
             address
         )
@@ -2154,7 +1934,6 @@ class BasisTradingStrategy(BasisSnapshotMixin, Strategy):
                 )
 
     async def _close_position(self) -> StatusTuple:
-        """Close the current position."""
         if self.current_position is None:
             return (True, "No position to close")
 
@@ -2187,7 +1966,7 @@ class BasisTradingStrategy(BasisSnapshotMixin, Strategy):
                 spot_asset_id=pos.spot_asset_id,
                 perp_asset_id=pos.perp_asset_id,
                 total_units=close_units,
-                direction="short_spot_long_perp",  # Reverse to close
+                direction="short_spot_long_perp",
                 builder_fee=self.builder_fee,
             )
 
@@ -2216,36 +1995,18 @@ class BasisTradingStrategy(BasisSnapshotMixin, Strategy):
         deposited_amount: float,
         best: dict[str, Any] | None = None,
     ) -> tuple[bool, str]:
-        """
-        Check if current delta-neutral position needs rebalancing.
-
-        Implements the following health checks:
-        1. Missing positions
-        2. Asset mismatch (if best specified)
-        3. Funding accumulation threshold
-        4. Perp must be SHORT
-        5. Position imbalance (±4% dust tolerance)
-        6. Unused bankroll
-        7. Stop-loss orders exist and are valid
-
-        Returns:
-            (needs_rebalance, reason) - True if rebalance needed
-        """
         perp_position = self._get_perp_position(state)
         spot_position = await self._get_spot_position()
 
-        # Check 1: Missing positions
         if perp_position is None or spot_position is None:
             return True, "Missing perp or spot position"
 
-        # Check 2: Asset mismatch (if best specified)
         if best:
             if perp_position.get("asset_id") != best.get("perp_asset_id"):
                 return True, "Perp asset mismatch"
             if spot_position.get("asset_id") != best.get("spot_asset_id"):
                 return True, "Spot asset mismatch"
 
-        # Check 3: Funding accumulation threshold
         funding_earned = self._get_funding_earned(state)
         if funding_earned > deposited_amount * self.FUNDING_REBALANCE_THRESHOLD:
             return True, f"Funding earned {funding_earned:.2f} exceeds threshold"
@@ -2255,7 +2016,6 @@ class BasisTradingStrategy(BasisSnapshotMixin, Strategy):
         if perp_size >= 0:
             return True, "Perp position is not short"
 
-        # Check 5: Position imbalance (±4% dust tolerance)
         spot_size = abs(float(spot_position.get("total", 0)))
         perp_size_abs = abs(perp_size)
         lower = spot_size * (1 - self.SPOT_POSITION_DUST_TOLERANCE)
@@ -2268,13 +2028,11 @@ class BasisTradingStrategy(BasisSnapshotMixin, Strategy):
         # there's idle capital - that should be added to the existing position.
 
         # Note: Stop-loss validation is handled separately in _monitor_position's
-        # Check 4 (_ensure_stop_loss_valid) which will place/update orders as needed
         # without triggering a full rebalance.
 
         return False, "Position healthy"
 
     def _get_perp_position(self, state: dict[str, Any]) -> dict[str, Any] | None:
-        """Extract perp position matching current position from user state."""
         if self.current_position is None:
             return None
 
@@ -2289,7 +2047,6 @@ class BasisTradingStrategy(BasisSnapshotMixin, Strategy):
         return None
 
     async def _get_spot_position(self) -> dict[str, Any] | None:
-        """Get spot position from spot user state."""
         if self.current_position is None:
             return None
 
@@ -2310,7 +2067,6 @@ class BasisTradingStrategy(BasisSnapshotMixin, Strategy):
         return None
 
     def _get_funding_earned(self, state: dict[str, Any]) -> float:
-        """Extract cumulative funding earned from user state."""
         if self.current_position is None:
             return 0.0
 
@@ -2332,18 +2088,8 @@ class BasisTradingStrategy(BasisSnapshotMixin, Strategy):
         spot_asset_id: int | None = None,
         spot_position_size: float | None = None,
     ) -> tuple[bool, str]:
-        """
-        Place stop-loss orders for both perp and spot legs.
-
-        For basis trading:
-        - Perp leg: Stop-market trigger order (buy to close short when price rises)
-        - Spot leg: Limit sell order (sell spot at stop-loss price)
-
-        Both orders together maintain delta neutrality when the stop-loss is hit.
-        """
         address = self._get_strategy_wallet_address()
 
-        # Get spot info from current position if not provided
         if spot_asset_id is None or spot_position_size is None:
             if self.current_position:
                 spot_asset_id = self.current_position.spot_asset_id
@@ -2352,7 +2098,6 @@ class BasisTradingStrategy(BasisSnapshotMixin, Strategy):
                 spot_asset_id = None
                 spot_position_size = 0.0
 
-        # Calculate stop-loss trigger price (90% of distance to liquidation)
         # For short perp, liquidation is ABOVE entry price
         stop_loss_price = (
             entry_price
@@ -2361,7 +2106,6 @@ class BasisTradingStrategy(BasisSnapshotMixin, Strategy):
         # Round to 5 significant figures to avoid SDK float_to_wire precision errors
         stop_loss_price = float(f"{stop_loss_price:.5g}")
 
-        # Get all open orders (frontend_open_orders includes trigger orders)
         success, open_orders = await self.hyperliquid_adapter.get_frontend_open_orders(
             address
         )
@@ -2384,9 +2128,8 @@ class BasisTradingStrategy(BasisSnapshotMixin, Strategy):
                 order_id = order.get("oid")
                 is_trigger = order.get("isTrigger", False)
                 order_type = str(order.get("orderType", "")).lower()
-                is_sell = order.get("side", "").upper() == "A"  # "A" = Ask/Sell
+                is_sell = order.get("side", "").upper() == "A"
 
-                # Check PERP trigger orders (stop-loss)
                 if order_coin == coin:
                     is_trigger_order = (
                         is_trigger or "stop" in order_type or "trigger" in order_type
@@ -2414,13 +2157,11 @@ class BasisTradingStrategy(BasisSnapshotMixin, Strategy):
                                     (perp_asset_id, order_id, "perp stop-loss")
                                 )
 
-                # Check SPOT limit sell orders
                 if spot_coin and order_coin == spot_coin and is_sell:
                     # This is a spot sell order (could be our stop-loss limit)
                     existing_price = float(order.get("limitPx", 0))
                     existing_size = float(order.get("sz", 0))
 
-                    # Check if it's around our stop-loss price (within 5%)
                     price_match = (
                         abs(existing_price - stop_loss_price) / stop_loss_price < 0.05
                     )
@@ -2455,7 +2196,7 @@ class BasisTradingStrategy(BasisSnapshotMixin, Strategy):
         if not has_valid_perp_stop:
             success, result = await self.hyperliquid_adapter.place_stop_loss(
                 asset_id=perp_asset_id,
-                is_buy=True,  # Buy to close short
+                is_buy=True,
                 trigger_price=stop_loss_price,
                 size=position_size,
                 address=address,
@@ -2471,18 +2212,17 @@ class BasisTradingStrategy(BasisSnapshotMixin, Strategy):
             and spot_position_size > 0
             and not has_valid_spot_limit
         ):
-            # Get valid order size for spot
             spot_sell_size = self.hyperliquid_adapter.get_valid_order_size(
                 spot_asset_id, spot_position_size
             )
             if spot_sell_size > 0:
                 success, result = await self.hyperliquid_adapter.place_limit_order(
                     asset_id=spot_asset_id,
-                    is_buy=False,  # Sell
+                    is_buy=False,
                     price=stop_loss_price,
                     size=spot_sell_size,
                     address=address,
-                    reduce_only=False,  # Spot doesn't have reduce_only
+                    reduce_only=False,
                 )
                 if not success:
                     self.logger.warning(f"Failed to place spot limit sell: {result}")
@@ -2499,7 +2239,6 @@ class BasisTradingStrategy(BasisSnapshotMixin, Strategy):
     # ------------------------------------------------------------------ #
 
     async def _get_last_rotation_time(self) -> datetime | None:
-        """Get timestamp of last position rotation from ledger."""
         wallet_address = self._get_strategy_wallet_address()
 
         try:
@@ -2528,7 +2267,6 @@ class BasisTradingStrategy(BasisSnapshotMixin, Strategy):
             return None
 
     async def _is_rotation_allowed(self) -> tuple[bool, str]:
-        """Check if rotation cooldown has passed."""
         if self.current_position is None:
             return True, "No existing position"
 
@@ -2555,29 +2293,20 @@ class BasisTradingStrategy(BasisSnapshotMixin, Strategy):
     # ------------------------------------------------------------------ #
 
     async def _get_total_portfolio_value(self) -> tuple[float, float, float]:
-        """
-        Get total portfolio value including Hyperliquid and vault balances.
-
-        Returns:
-            (total_value, hyperliquid_value, vault_wallet_value)
-        """
         address = self._get_strategy_wallet_address()
 
-        # Get Hyperliquid account value
         hl_value = 0.0
         success, user_state = await self.hyperliquid_adapter.get_user_state(address)
         if success:
             margin_summary = user_state.get("marginSummary", {})
             hl_value = float(margin_summary.get("accountValue", 0))
 
-            # Add spot value (all spot holdings, not just USDC)
             (
                 success_spot,
                 spot_state,
             ) = await self.hyperliquid_adapter.get_spot_user_state(address)
             if success_spot:
                 spot_balances = spot_state.get("balances", [])
-                # Get mid prices for non-USDC assets
                 mid_prices: dict[str, float] = {}
                 if any(bal.get("coin") != "USDC" for bal in spot_balances):
                     (
@@ -2606,7 +2335,6 @@ class BasisTradingStrategy(BasisSnapshotMixin, Strategy):
                                 f"No mid price found for spot {coin}, skipping"
                             )
 
-        # Get strategy wallet USDC balance (on Arbitrum)
         strategy_wallet_value = 0.0
         try:
             strategy_address = self._get_strategy_wallet_address()
@@ -2615,7 +2343,7 @@ class BasisTradingStrategy(BasisSnapshotMixin, Strategy):
                 wallet_address=strategy_address,
             )
             if success and balance:
-                strategy_wallet_value = float(balance) / 1e6  # Convert from raw to USDC
+                strategy_wallet_value = float(balance) / 1e6
         except Exception as e:
             self.logger.debug(f"Could not fetch strategy wallet balance: {e}")
 
@@ -2632,7 +2360,6 @@ class BasisTradingStrategy(BasisSnapshotMixin, Strategy):
         idx_to_token: dict[int, str],
         perps_set: set[str],
     ) -> list[tuple[str, str, int]]:
-        """Find spot-perp pairs that can form basis trades."""
         candidates: list[tuple[str, str, int]] = []
 
         for pe in spot_pairs:
@@ -2650,7 +2377,6 @@ class BasisTradingStrategy(BasisSnapshotMixin, Strategy):
             spot_pair_name = f"{base}/{quote}"
             spot_asset_id = pe["index"] + 10000
 
-            # Handle USDT prefixed tokens (UPUMP -> PUMP)
             base_norm = (
                 base[1:] if (base.startswith("U") and base[1:] in perps_set) else base
             )
@@ -2672,7 +2398,6 @@ class BasisTradingStrategy(BasisSnapshotMixin, Strategy):
         perp_coin_to_asset_id: dict[str, int],
         depth_params: dict[str, Any] | None = None,
     ) -> list[BasisCandidate]:
-        """Filter candidates by liquidity and venue depth, returning structured data."""
         liquid: list[BasisCandidate] = []
 
         if deposit_usdc <= 0:
@@ -2706,7 +2431,6 @@ class BasisTradingStrategy(BasisSnapshotMixin, Strategy):
             if order_usd <= 0:
                 continue
 
-            # Get spot order book
             try:
                 book_snapshot = await self._l2_book_spot(
                     spot_asset_id,
@@ -2764,29 +2488,14 @@ class BasisTradingStrategy(BasisSnapshotMixin, Strategy):
     # Chunked Data Fetching                                               #
     # ------------------------------------------------------------------ #
 
-    HOURS_PER_CHUNK = 500  # Hyperliquid API returns max 500 data points per call
-    CHUNK_DELAY_SECONDS = 0.2  # Delay between API chunks to avoid rate limiting
+    HOURS_PER_CHUNK = 500
+    CHUNK_DELAY_SECONDS = 0.2
 
     def _hour_chunks(
         self, start_ms: int, end_ms: int, step_hours: int = 500
     ) -> list[tuple[int, int]]:
-        """
-        Generate time chunks for API calls.
-
-        Each chunk is (start_ms, end_ms) tuple representing a time window
-        of up to `step_hours` hours. This allows fetching >500 data points
-        by making multiple API calls.
-
-        Args:
-            start_ms: Start time in milliseconds
-            end_ms: End time in milliseconds
-            step_hours: Hours per chunk (default 500, Hyperliquid API limit)
-
-        Returns:
-            List of (chunk_start_ms, chunk_end_ms) tuples
-        """
         chunks = []
-        step_ms = step_hours * 3600 * 1000  # Convert hours to milliseconds
+        step_ms = step_hours * 3600 * 1000
         t0 = start_ms
 
         while t0 < end_ms:
@@ -2802,30 +2511,14 @@ class BasisTradingStrategy(BasisSnapshotMixin, Strategy):
         start_ms: int,
         end_ms: int | None = None,
     ) -> tuple[bool, list[dict[str, Any]]]:
-        """
-        Fetch funding history with automatic chunking for long time ranges.
-
-        Hyperliquid API returns max ~500 data points per call. This method
-        automatically splits long requests into multiple chunks and merges
-        the results.
-
-        Args:
-            coin: Coin symbol (e.g., "ETH", "BTC")
-            start_ms: Start time in milliseconds
-            end_ms: End time in milliseconds (defaults to now)
-
-        Returns:
-            (success, combined_funding_data)
-        """
         if end_ms is None:
             end_ms = int(time.time() * 1000)
 
         chunks = self._hour_chunks(start_ms, end_ms, self.HOURS_PER_CHUNK)
         all_funding: list[dict[str, Any]] = []
-        seen_times: set[int] = set()  # Dedupe by timestamp
+        seen_times: set[int] = set()
 
         for i, (chunk_start, chunk_end) in enumerate(chunks):
-            # Add delay between chunks to avoid rate limiting
             if i > 0:
                 await asyncio.sleep(self.CHUNK_DELAY_SECONDS)
 
@@ -2866,27 +2559,14 @@ class BasisTradingStrategy(BasisSnapshotMixin, Strategy):
         start_ms: int,
         end_ms: int | None = None,
     ) -> tuple[bool, list[dict[str, Any]]]:
-        """
-        Fetch candle data with automatic chunking for long time ranges.
-
-        Args:
-            coin: Coin symbol (e.g., "ETH", "BTC")
-            interval: Candle interval (e.g., "1h")
-            start_ms: Start time in milliseconds
-            end_ms: End time in milliseconds (defaults to now)
-
-        Returns:
-            (success, combined_candle_data)
-        """
         if end_ms is None:
             end_ms = int(time.time() * 1000)
 
         chunks = self._hour_chunks(start_ms, end_ms, self.HOURS_PER_CHUNK)
         all_candles: list[dict[str, Any]] = []
-        seen_times: set[int] = set()  # Dedupe by open timestamp
+        seen_times: set[int] = set()
 
         for i, (chunk_start, chunk_end) in enumerate(chunks):
-            # Add delay between chunks to avoid rate limiting
             if i > 0:
                 await asyncio.sleep(self.CHUNK_DELAY_SECONDS)
 
@@ -2931,7 +2611,6 @@ class BasisTradingStrategy(BasisSnapshotMixin, Strategy):
         *,
         fallback_mid: float | None = None,
     ) -> dict[str, Any]:
-        """Normalize Hyperliquid L2 into bids/asks lists with floats."""
         return hl_normalize_l2_book(raw, fallback_mid=fallback_mid)
 
     async def _l2_book_spot(
@@ -2941,7 +2620,6 @@ class BasisTradingStrategy(BasisSnapshotMixin, Strategy):
         fallback_mid: float | None = None,
         spot_symbol: str | None = None,
     ) -> dict[str, Any]:
-        """Fetch and normalize Level-2 order book snapshot for a spot asset."""
         last_exc: Exception | None = None
 
         try:
@@ -2997,7 +2675,6 @@ class BasisTradingStrategy(BasisSnapshotMixin, Strategy):
         max_bps: int = 100,
         gamma: int = 20,
     ) -> int:
-        """Widen the depth band slowly with order size."""
         if order_usd <= 0:
             return base_bps
 
@@ -3017,12 +2694,6 @@ class BasisTradingStrategy(BasisSnapshotMixin, Strategy):
         fallback_mid: float | None = None,
         spot_symbol: str | None = None,
     ) -> dict[str, Any]:
-        """
-        Heuristic spot book depth gate using USD notionals.
-
-        Returns diagnostics including available depth, thresholds, and pass/fail flags.
-        """
-
         config: dict[str, Any] = {
             "base_band_bps": 50,
             "max_band_bps": 100,
@@ -3148,8 +2819,6 @@ class BasisTradingStrategy(BasisSnapshotMixin, Strategy):
         day_ntl_usd: float | None = None,
         spot_symbol: str | None = None,
     ) -> tuple[float, float, dict[str, float], dict[str, dict[str, Any]]]:
-        """Estimate entry/exit execution costs for a full cycle on both legs."""
-
         cfg_fees = {"spot_bps": 9.0, "perp_bps": 6.0}
         if fee_model:
             cfg_fees.update(fee_model)
@@ -3210,7 +2879,6 @@ class BasisTradingStrategy(BasisSnapshotMixin, Strategy):
         return entry_cost, exit_cost, breakdown, {"buy": buy_chk, "sell": sell_chk}
 
     async def _get_margin_table_tiers(self, table_id: int) -> list[dict[str, float]]:
-        """Fetch and cache margin table tiers with maintenance rates and deductions."""
         if table_id in self._margin_table_cache:
             return [dict(t) for t in self._margin_table_cache[table_id]]
 
@@ -3275,7 +2943,6 @@ class BasisTradingStrategy(BasisSnapshotMixin, Strategy):
         notional_usd: float,
         fallback_max_leverage: int,
     ) -> float:
-        """Return maintenance margin fraction for a given notional, honoring tiered tables."""
         fallback_mmr = self.maintenance_rate_from_max_leverage(
             max(1, int(fallback_max_leverage))
         )
@@ -3316,7 +2983,6 @@ class BasisTradingStrategy(BasisSnapshotMixin, Strategy):
         maintenance_fn,
         base_notional: float,
     ) -> int:
-        """Return the forward hours until the stop barrier is hit or data is exhausted."""
         n = min(len(closes), len(highs), len(hourly_funding)) - 1
         if start_idx >= n:
             return 0
@@ -3370,7 +3036,6 @@ class BasisTradingStrategy(BasisSnapshotMixin, Strategy):
         fallback_max_leverage: int,
         cooloff_hours: int = 0,
     ) -> dict[str, float]:
-        """Simulate repeated entries/exits under a stop barrier and accumulate PnL."""
         n = min(len(funding), len(closes), len(highs)) - 1
         if n <= 0:
             return {
@@ -3446,7 +3111,6 @@ class BasisTradingStrategy(BasisSnapshotMixin, Strategy):
 
     @staticmethod
     def _percentile(sorted_values: list[float], pct: float) -> float:
-        """Inclusive percentile on a pre-sorted list."""
         return analytics_percentile(sorted_values, pct)
 
     def _block_bootstrap_paths(
@@ -3459,7 +3123,6 @@ class BasisTradingStrategy(BasisSnapshotMixin, Strategy):
         sims: int,
         rng: random.Random,
     ) -> list[tuple[list[float], list[float], list[float]]]:
-        """Return block-bootstrap resampled series for funding/close/high paths."""
         paths = analytics_block_bootstrap_paths(
             funding,
             closes,
@@ -3490,7 +3153,6 @@ class BasisTradingStrategy(BasisSnapshotMixin, Strategy):
         block_hours: int,
         seed: int | None,
     ) -> dict[str, Any] | None:
-        """Run block-bootstrap replays and summarize churn metrics."""
         if sims <= 0 or deposit_usdc <= 0:
             return None
 
@@ -3597,8 +3259,6 @@ class BasisTradingStrategy(BasisSnapshotMixin, Strategy):
         fee_eps: float,
         require_full_window: bool = True,
     ) -> float:
-        """Worst-case buffer requirement accounting for tiered maintenance margin."""
-
         fallback_mmr = self.maintenance_rate_from_max_leverage(
             max(1, int(fallback_max_leverage))
         )
@@ -3659,7 +3319,6 @@ class BasisTradingStrategy(BasisSnapshotMixin, Strategy):
     def round_size_for_hypecore_asset(
         self, asset_id: int, size: float | Decimal, *, ensure_min_step: bool = False
     ) -> float:
-        """Floor to step using Decimal to avoid float issues."""
         try:
             mapping = self.hyperliquid_adapter.asset_to_sz_decimals
         except Exception as exc:  # noqa: BLE001
@@ -3688,11 +3347,6 @@ class BasisTradingStrategy(BasisSnapshotMixin, Strategy):
         spot_asset_id: int,
         perp_asset_id: int | None,
     ) -> float:
-        """
-        Minimum USDC deposit to place at least one lot on both legs at leverage L.
-
-        D_min(L) = N * (1 + 1/L), with N = unit_step * mark_px.
-        """
         L = max(1, int(leverage))
         unit_step = self._common_unit_step(spot_asset_id, perp_asset_id)
         mark = _d(mark_price)
@@ -3708,11 +3362,6 @@ class BasisTradingStrategy(BasisSnapshotMixin, Strategy):
         day_ntl_usd: float | None,
         params: dict[str, Any] | None,
     ) -> float:
-        """
-        Conservative upper bound for order size that could ever pass depth checks.
-
-        Uses depth at max band and turnover cap (if provided).
-        """
         config: dict[str, Any] = {
             "max_band_bps": 100,
             "max_fill_ratio": 0.10,
@@ -3769,12 +3418,6 @@ class BasisTradingStrategy(BasisSnapshotMixin, Strategy):
         params: dict[str, Any] | None = None,
         refine_iters: int = 12,
     ) -> dict[str, Any]:
-        """
-        Compute the maximum order_usd that passes spot depth checks on both sides.
-
-        This is used for batch precompute so workers can quickly filter candidates
-        by a user's required order size.
-        """
         upper_buy = self._depth_upper_bound_usd(
             book=book, side="buy", day_ntl_usd=day_ntl_usd, params=params
         )
@@ -3933,8 +3576,6 @@ class BasisTradingStrategy(BasisSnapshotMixin, Strategy):
         bootstrap_block_hours: int = DEFAULT_BOOTSTRAP_BLOCK_HOURS,
         bootstrap_seed: int | None = None,
     ) -> list[dict[str, Any]]:
-        """Rank spot/perp pairs by simulated net APY under stop-driven churn."""
-
         if deposit_usdc <= 0:
             return []
 
@@ -4159,22 +3800,18 @@ class BasisTradingStrategy(BasisSnapshotMixin, Strategy):
     # ------------------------------------------------------------------ #
 
     def _z_from_conf(self, confidence: float) -> float:
-        """Get z-score for given confidence level."""
         return analytics_z_from_conf(confidence)
 
     def _rolling_min_sum(self, arr: list[float], window: int) -> float:
-        """Calculate minimum rolling sum over window."""
         return analytics_rolling_min_sum(arr, window)
 
     @staticmethod
     def maintenance_rate_from_max_leverage(max_lev: int) -> float:
-        """Estimate maintenance margin rate from max leverage."""
         if max_lev <= 0:
             return 0.5
         return 0.5 / max_lev
 
     def _get_strategy_wallet_address(self) -> str:
-        """Get strategy wallet address from config."""
         strategy_wallet = self.config.get("strategy_wallet")
         if not strategy_wallet or not isinstance(strategy_wallet, dict):
             raise ValueError("strategy_wallet not configured")
@@ -4184,7 +3821,6 @@ class BasisTradingStrategy(BasisSnapshotMixin, Strategy):
         return str(address)
 
     def _get_main_wallet_address(self) -> str:
-        """Get main wallet address from config."""
         main_wallet = self.config.get("main_wallet")
         if not main_wallet or not isinstance(main_wallet, dict):
             raise ValueError("main_wallet not configured")