Enhance High Leverage API and Streamlit Page with Bootable User Details

goldhaxx · goldhaxx · commit 1659fa999685 · 2025-05-14T10:09:37.000-07:00
- Added a new endpoint `/bootable-users` to the High Leverage API, providing detailed information about users in high leverage mode who are deemed bootable due to inactivity.
- Introduced a new `BootableUserDetails` model to encapsulate user data for bootable users, including fields such as account leverage, activity staleness, and health percentage.
- Updated the Streamlit page to display bootable user details, enhancing user experience by providing insights into inactive high leverage users.
- Improved logging and error handling in both the API and Streamlit components to ensure robust data processing and user feedback.

These changes significantly enhance the functionality and usability of the High Leverage features in the application, allowing for better management of user activity and leverage status.
diff --git a/backend/api/high_leverage_api.py b/backend/api/high_leverage_api.py
@@ -10,7 +10,7 @@
 from driftpy.drift_user import DriftUser 
 from driftpy.user_map.user_map import UserMap # Assuming UserMap is accessible
 from driftpy.types import PerpPosition, UserAccount, is_variant, OraclePriceData # Added OraclePriceData
-from driftpy.constants.numeric_constants import PRICE_PRECISION, MARGIN_PRECISION, BASE_PRECISION # Added BASE_PRECISION
+from driftpy.constants.numeric_constants import PRICE_PRECISION, MARGIN_PRECISION, BASE_PRECISION, QUOTE_PRECISION # Added QUOTE_PRECISION
 from driftpy.constants.perp_markets import mainnet_perp_market_configs # Added mainnet_perp_market_configs
 from driftpy.pickle.vat import Vat # Added Vat for type hinting
 from driftpy.math.margin import MarginCategory # Added MarginCategory
@@ -24,6 +24,10 @@
 
 # Decimals for perp market base asset amount
 PERP_DECIMALS = 9
+# Slot inactivity threshold for considering a user bootable (approx 10 minutes)
+SLOT_INACTIVITY_THRESHOLD = 9000
+# Optional: Leverage threshold for booting (e.g., 25x)
+# BOOT_LEVERAGE_THRESHOLD = 25 # Not strictly implementing this yet, focusing on inactivity
 
 class HighLeverageStats(BaseModel):
     slot: int # Added slot field
@@ -42,38 +46,44 @@ class HighLeveragePositionDetail(BaseModel):
     account_leverage: float # Renamed from leverage
     position_leverage: float # Added position-specific leverage
 
+class BootableUserDetails(BaseModel):
+    user_public_key: str
+    authority: str
+    account_leverage: float
+    activity_staleness_slots: int
+    last_active_slot: int
+    initial_margin_requirement_usd: float
+    total_collateral_usd: float
+    health_percent: int # User's health percentage
+
 @router.get("/stats", response_model=HighLeverageStats)
 async def get_high_leverage_stats(request: BackendRequest):
     """
     Provides statistics about high leverage usage on the Drift protocol.
     - Total spots: Maximum users allowed in high leverage mode (hardcoded).
     - Opted-in spots: Users currently opted into high leverage mode.
     - Available spots: Spots remaining for users to opt-in.
-    - Bootable spots: Users opted-in but not actively using high leverage (no significant perp positions).
+    - Bootable spots: Users opted-in, inactive for a defined period, and potentially with low overall leverage.
     """
     
     total_spots = 400  # Hardcoded maximum number of spots
 
     opted_in_users_count = 0
     bootable_count = 0
     
-    # --- Get Slot --- 
-    # Use getattr for safer access, default to 0 or handle appropriately if slot is critical
-    slot = getattr(request.state.backend_state, 'last_oracle_slot', 0) 
-    if slot == 0:
-        logger.warning("Could not retrieve last_oracle_slot from backend state.")
-        # Decide how to handle missing slot: raise error, return default, etc.
-        # For now, it will return 0 as the slot.
-
-    # --- Access UserMap --- 
+    current_slot = getattr(request.state.backend_state, 'last_oracle_slot', 0) 
+    if current_slot == 0:
+        logger.warning("Could not retrieve current_slot (last_oracle_slot) from backend state for /stats. Bootable check might be inaccurate.")
+        # If current_slot is critical for bootable check, might return error or default.
+        # For now, proceeding will mean inactivity check can't be reliably performed if current_slot is 0.
+
     user_map: Optional[UserMap] = getattr(request.state.backend_state, 'user_map', None)
     logger.info(f"UserMap object type from state: {type(user_map)}")
 
     if not user_map or not hasattr(user_map, 'values'):
         logger.warning("UserMap not found or invalid in backend state. Returning default stats.")
-        # Return default values, including the fetched slot (which might be 0)
         return HighLeverageStats(
-            slot=slot, 
+            slot=current_slot, 
             total_spots=total_spots,
             available_spots=total_spots, 
             bootable_spots=0,
@@ -86,13 +96,13 @@ async def get_high_leverage_stats(request: BackendRequest):
         
         if not user_values:
              logger.info("UserMap is empty for /stats.")
-        else:
-             logger.info(f"First user object type for /stats: {type(user_values[0])}")
+        # else: # Logging first user type can be verbose, let's assume it's DriftUser by now
+             # logger.info(f"First user object type for /stats: {type(user_values[0])}")
 
     except Exception as e:
         logger.error(f"Error getting users from UserMap for /stats: {e}", exc_info=True)
         return HighLeverageStats(
-            slot=slot,
+            slot=current_slot,
             total_spots=total_spots,
             available_spots=total_spots, 
             bootable_spots=0,
@@ -105,37 +115,47 @@ async def get_high_leverage_stats(request: BackendRequest):
              continue
 
         is_high_leverage = False
+        user_account: Optional[UserAccount] = None # Define here for broader scope
         try:
             is_high_leverage = user.is_high_leverage_mode()
+            if is_high_leverage:
+                user_account = user.get_user_account()
         except Exception as e:
-            logger.error(f"Error checking high leverage status for user {user.user_public_key} in /stats: {e}", exc_info=True)
+            logger.error(f"Error checking high leverage status or getting account for user {user.user_public_key} in /stats: {e}", exc_info=True)
             continue 
 
-        if is_high_leverage:
+        if is_high_leverage and user_account:
             opted_in_users_count += 1
             
-            has_open_perp_positions = False
-            try:
-                user_account: UserAccount = user.get_user_account() 
-                perp_positions: list[PerpPosition] = user_account.perp_positions
-                
-                for position in perp_positions:
-                    if position.base_asset_amount != 0:
-                        has_open_perp_positions = True
-                        break 
-            except Exception as e:
-                 logger.error(f"Error checking positions for user {user.user_public_key} in /stats: {e}", exc_info=True)
-                 has_open_perp_positions = True 
+            # Check for bootable status based on inactivity
+            is_inactive = False
+            if current_slot > 0: # Ensure current_slot is valid before checking inactivity
+                try:
+                    last_active_slot = user_account.last_active_slot # This is a int/BN
+                    # Ensure last_active_slot can be converted to int if it's a BN or similar type
+                    last_active_slot_int = int(str(last_active_slot)) 
+                    if (current_slot - last_active_slot_int) > SLOT_INACTIVITY_THRESHOLD:
+                        is_inactive = True
+                        logger.debug(f"User {user.user_public_key} is inactive. Current: {current_slot}, Last Active: {last_active_slot_int}, Diff: {current_slot - last_active_slot_int}")
+                except Exception as slot_check_e:
+                    logger.error(f"Error checking inactivity for user {user.user_public_key}: {slot_check_e}", exc_info=True)
+                    # Decide behavior: treat as not inactive, or skip bootable check for this user
             
-            if not has_open_perp_positions:
+            # The bot script uses inactivity and a general low leverage threshold.
+            # For simplicity and alignment with bot, we use inactivity as the primary signal.
+            # A stricter check could verify no *significant* positions or overall low leverage.
+            if is_inactive:
+                # Optionally, add the leverage check here if desired for stricter booting criteria:
+                # current_leverage_ui = user.get_leverage() / MARGIN_PRECISION
+                # if current_leverage_ui < BOOT_LEVERAGE_THRESHOLD:
+                #     bootable_count += 1
                 bootable_count += 1
 
     available_spots = total_spots - opted_in_users_count
-    logger.info(f"Calculated Stats for /stats: Slot={slot}, Total={total_spots}, OptedIn={opted_in_users_count}, Available={available_spots}, Bootable={bootable_count}")
+    logger.info(f"Calculated Stats for /stats: Slot={current_slot}, Total={total_spots}, OptedIn={opted_in_users_count}, Available={available_spots}, Bootable={bootable_count}")
 
-    # Include slot in the returned object
     return HighLeverageStats(
-        slot=slot, 
+        slot=current_slot, 
         total_spots=total_spots,
         available_spots=available_spots,
         bootable_spots=bootable_count,
@@ -250,4 +270,76 @@ async def get_high_leverage_positions_detailed(request: BackendRequest):
             continue # Skip to next user on error
             
     logger.info(f"Returning {len(detailed_hl_positions)} high leverage positions.")
-    return detailed_hl_positions
+    return detailed_hl_positions
+
+@router.get("/bootable-users", response_model=List[BootableUserDetails])
+async def get_bootable_user_details(request: BackendRequest):
+    """
+    Returns detailed information for users who are in high leverage mode and deemed bootable due to inactivity.
+    """
+    bootable_users_list: List[BootableUserDetails] = []
+
+    current_slot = getattr(request.state.backend_state, 'last_oracle_slot', 0)
+    user_map: Optional[UserMap] = getattr(request.state.backend_state, 'user_map', None)
+
+    logger.info(f"Fetching bootable users details. Current slot: {current_slot}")
+
+    if current_slot == 0:
+        logger.warning("Current slot is 0, cannot accurately determine bootable users by inactivity. Returning empty list.")
+        return []
+    
+    if not user_map or not hasattr(user_map, 'values'):
+        logger.warning("UserMap not found or invalid in backend state. Returning empty list for /bootable-users.")
+        return []
+
+    try:
+        user_values = list(user_map.values())
+        logger.info(f"Processing {len(user_values)} users from UserMap for /bootable-users.")
+    except Exception as e:
+        logger.error(f"Error getting users from UserMap for /bootable-users: {e}", exc_info=True)
+        return []
+
+    for user in user_values:
+        if not isinstance(user, DriftUser):
+            logger.warning(f"Skipping item, expected DriftUser, got {type(user)}")
+            continue
+        
+        user_account: Optional[UserAccount] = None
+        try:
+            if user.is_high_leverage_mode():
+                user_account = user.get_user_account()
+                if not user_account:
+                    logger.warning(f"User {user.user_public_key} is high leverage but failed to get user_account. Skipping.")
+                    continue
+
+                last_active_slot_int = int(str(user_account.last_active_slot))
+                activity_staleness_slots = current_slot - last_active_slot_int
+
+                if activity_staleness_slots > SLOT_INACTIVITY_THRESHOLD:
+                    logger.debug(f"User {user.user_public_key} is bootable. Staleness: {activity_staleness_slots} slots.")
+                    
+                    account_leverage_ui = user.get_leverage() / MARGIN_PRECISION
+                    initial_margin_req_usd = user.get_margin_requirement(MarginCategory.INITIAL) / QUOTE_PRECISION
+                    total_collateral_usd = user.get_total_collateral(MarginCategory.INITIAL) / QUOTE_PRECISION
+                    health_percent = user.get_health()
+                    user_public_key_str = str(user.user_public_key)
+                    authority_str = str(user_account.authority)
+
+                    bootable_users_list.append(
+                        BootableUserDetails(
+                            user_public_key=user_public_key_str,
+                            authority=authority_str,
+                            account_leverage=account_leverage_ui,
+                            activity_staleness_slots=activity_staleness_slots,
+                            last_active_slot=last_active_slot_int,
+                            initial_margin_requirement_usd=initial_margin_req_usd,
+                            total_collateral_usd=total_collateral_usd,
+                            health_percent=health_percent,
+                        )
+                    )
+        except Exception as user_proc_e:
+            logger.error(f"Error processing user {getattr(user, 'user_public_key', 'UNKNOWN')} for /bootable-users: {user_proc_e}", exc_info=True)
+            continue
+            
+    logger.info(f"Found {len(bootable_users_list)} bootable users.")
+    return bootable_users_list
diff --git a/src/page/high_leverage_page.py b/src/page/high_leverage_page.py
@@ -130,22 +130,22 @@ def high_leverage_page():
         cols[0].metric("Total High Leverage Spots", stats_data.get('total_spots', 'N/A'))
         cols[1].metric("Opted-In Users", stats_data.get('opted_in_spots', 'N/A'))
         cols[2].metric("Available Spots", stats_data.get('available_spots', 'N/A'))
-        cols[3].metric("Bootable Spots (Opted-in, No Position)", stats_data.get('bootable_spots', 'N/A'))
+        cols[3].metric("Bootable Spots (Inactive)", stats_data.get('bootable_spots', 'N/A')) # Updated label
 
         st.subheader("Detailed High Leverage Positions")
         if not display_df.empty:
             # Apply Pandas Styler for formatting
             styled_df = display_df.style.format({
-                'Base Asset Amount': '{:,.4f}',         # Commas, 4 decimal places
-                'Notional Value (USD)': '${:,.2f}',      # Commas, 2 decimal places, no $
-                'Position Leverage': '{:.2f}x',         # 2 decimal places, 'x' suffix
-                'Account Leverage': '{:.2f}x'          # 2 decimal places, 'x' suffix
+                'Base Asset Amount': '{:,.4f}',
+                'Notional Value (USD)': '${:,.2f}',
+                'Position Leverage': '{:.2f}x',
+                'Account Leverage': '{:.2f}x'
             })
             st.dataframe(
-                styled_df,  # Pass the styled DataFrame
+                styled_df, 
                 hide_index=True, 
                 use_container_width=True,
-                column_config={ # Keep config for non-styled columns or for relabeling if needed
+                column_config={ 
                     "Market Symbol": st.column_config.TextColumn(label="Market Symbol"),
                     "User Account": st.column_config.TextColumn(label="User Account"),
                     "Authority": st.column_config.TextColumn(label="Authority"),
@@ -155,6 +155,82 @@ def high_leverage_page():
         else:
             st.info("No detailed high leverage position data available, or an error occurred during processing.")
 
+        # --- 8. Fetch and Display Bootable Users Details --- 
+        st.subheader("Bootable User Details (Inactive High Leverage Users)")
+        result_bootable_users = fetch_api_data(
+            section="high-leverage",
+            path="bootable-users",
+            retry=False
+        )
+
+        if is_processing(result_bootable_users):
+            st.info(f"Backend is processing bootable user data. Auto-refreshing in {RETRY_DELAY_SECONDS} seconds...")
+            # No need for a full page rerun here if other data is fine, but spinner helps UX
+            with st.spinner("Loading bootable users..."):
+                time.sleep(RETRY_DELAY_SECONDS) 
+            st.rerun() # Or trigger a more targeted refresh if possible
+            return 
+        
+        if has_error(result_bootable_users):
+            st.warning("Could not fetch Bootable User Details. This table will be empty.")
+            bootable_users_data = []
+        else:
+            bootable_users_data = result_bootable_users if isinstance(result_bootable_users, list) else []
+
+        df_bootable = pd.DataFrame()
+        if bootable_users_data:
+            try:
+                df_bootable = pd.DataFrame(bootable_users_data)
+                if not df_bootable.empty:
+                    df_bootable.rename(columns={
+                        'user_public_key': 'User Account',
+                        'authority': 'Authority',
+                        'account_leverage': 'Account Leverage',
+                        'activity_staleness_slots': 'Activity Staleness (Slots)',
+                        'last_active_slot': 'Last Active Slot',
+                        'initial_margin_requirement_usd': 'Initial Margin Req. (USD)',
+                        'total_collateral_usd': 'Total Collateral (USD)',
+                        'health_percent': 'Health (%)'
+                    }, inplace=True)
+
+                    # Ensure numeric types for sorting where applicable
+                    df_bootable['Account Leverage'] = pd.to_numeric(df_bootable['Account Leverage'], errors='coerce')
+                    df_bootable['Activity Staleness (Slots)'] = pd.to_numeric(df_bootable['Activity Staleness (Slots)'], errors='coerce')
+                    df_bootable['Initial Margin Req. (USD)'] = pd.to_numeric(df_bootable['Initial Margin Req. (USD)'], errors='coerce')
+                    df_bootable['Total Collateral (USD)'] = pd.to_numeric(df_bootable['Total Collateral (USD)'], errors='coerce')
+                    df_bootable['Health (%)'] = pd.to_numeric(df_bootable['Health (%)'], errors='coerce')
+
+                    # Default sort by Activity Staleness (descending)
+                    df_bootable = df_bootable.sort_values(by='Activity Staleness (Slots)', ascending=False)
+
+                    # Select and order columns for display
+                    display_bootable_df = df_bootable[[
+                        'User Account',
+                        'Authority',
+                        'Account Leverage',
+                        'Activity Staleness (Slots)',
+                        'Last Active Slot',
+                        'Initial Margin Req. (USD)',
+                        'Total Collateral (USD)',
+                        'Health (%)'
+                    ]].copy()
+
+                    # Display formatting using Pandas Styler
+                    styled_bootable_df = display_bootable_df.style.format({
+                        'Account Leverage': '{:.2f}x',
+                        'Activity Staleness (Slots)': '{:,.0f}',
+                        'Initial Margin Req. (USD)': '${:,.2f}',
+                        'Total Collateral (USD)': '${:,.2f}',
+                        'Health (%)': '{:.0f}%'
+                    })
+                    st.dataframe(styled_bootable_df, hide_index=True, use_container_width=True)
+                else:
+                    st.info("No bootable users found meeting the criteria.") # Message if data is empty after processing
+            except Exception as df_boot_e:
+                st.error(f"Error processing bootable user data into DataFrame: {df_boot_e}")
+        else:
+            st.info("No bootable user data to display.")
+
     except Exception as e:
         st.error(f"An error occurred while displaying the page: {e}")
         import traceback
