Merge pull request #49 from drift-labs:goldhaxx/DPE-3459/fix-risk-dashboard-loading-issues

Refactor deposits, and liquidation curve APIs & pages, update routing

Author: goldhaxx

backend/api/__init__.py

@@ -1,14 +1,19 @@
 from . import (
     asset_liability,
     backend_health,
-    deposits,
+    deposits_api,
     health,
-    liquidation,
+    high_leverage_api,
+    liquidation_curves_api,
+    market_recommender_api,
     metadata,
+    open_interest_api,
     pnl,
     positions,
     price_shock,
     snapshot,
     ucache,
+    user_retention_explorer_api,
+    user_retention_summary_api,
     vaults,
 )

backend/api/deposits.py renamed to backend/api/deposits_api.py

@@ -23,6 +23,7 @@ async def get_deposits(request: BackendRequest, market_index: Optional[int] = No
         dict: A dictionary containing deposits with total value and balance info
     """
     vat: Vat = request.state.backend_state.vat
+    last_oracle_slot = getattr(request.state.backend_state, "last_oracle_slot", 0)
     deposits = []
     vaults_program = await get_vaults_program(request.state.backend_state.connection)
     vaults = await vaults_program.account["Vault"].all()
@@ -53,6 +54,7 @@ async def get_deposits(request: BackendRequest, market_index: Optional[int] = No
 
     deposits.sort(key=lambda x: x["value"], reverse=True)
     return {
+        "slot": last_oracle_slot,
         "deposits": deposits,
         "vaults": vault_pubkeys,
         "total_value": sum(d["value"] for d in deposits),

backend/api/liquidation.py renamed to backend/api/liquidation_curves_api.py

@@ -7,15 +7,23 @@
 router = APIRouter()
 
 
-@router.get("/liquidation-curve")
+@router.get("/liquidation-curves")
 def get_liquidation_curve(request: BackendRequest, market_index: int):
     vat: Vat = request.state.backend_state.vat
+    last_oracle_slot = getattr(request.state.backend_state, "last_oracle_slot", 0)
+    # Debug logging to understand the slot issue
+    print(f"[DEBUG] Liquidation API - last_oracle_slot: {last_oracle_slot}, pickle_path: {request.state.backend_state.current_pickle_path}")
     liquidations_long: list[tuple[float, float, str]] = []
     liquidations_short: list[tuple[float, float, str]] = []
     market_price = vat.perp_oracles.get(market_index)
     if market_price is None:
         print("Market price is None")
-        return {"liquidations_long": [], "liquidations_short": [], "market_price_ui": 0}
+        return {
+            "liquidations_long": [], 
+            "liquidations_short": [], 
+            "market_price_ui": 0,
+            "slot": last_oracle_slot
+        }
     market_price_ui = market_price.price / PRICE_PRECISION
     for pubkey, user in vat.users.user_map.items():
         perp_position = user.get_perp_position(market_index)
@@ -48,4 +56,5 @@ def get_liquidation_curve(request: BackendRequest, market_index: int):
         "liquidations_long": liquidations_long,
         "liquidations_short": liquidations_short,
         "market_price_ui": market_price_ui,
+        "slot": last_oracle_slot,
     }

backend/app.py

@@ -11,9 +11,9 @@
 from backend.api import (
     asset_liability,
     backend_health,
-    deposits,
+    deposits_api,
     health,
-    liquidation,
+    liquidation_curves_api,
     market_recommender_api,
     metadata,
     open_interest_api,
@@ -80,14 +80,14 @@ async def lifespan(app: FastAPI):
 app.include_router(health.router, prefix="/api/health", tags=["health"])
 app.include_router(backend_health.router, prefix="/api/backend-health", tags=["backend-health"])
 app.include_router(metadata.router, prefix="/api/metadata", tags=["metadata"])
-app.include_router(liquidation.router, prefix="/api/liquidation", tags=["liquidation"])
+app.include_router(liquidation_curves_api.router, prefix="/api/liquidation-curves", tags=["liquidation-curves"])
 app.include_router(price_shock.router, prefix="/api/price-shock", tags=["price-shock"])
 app.include_router(
     asset_liability.router, prefix="/api/asset-liability", tags=["asset-liability"]
 )
 app.include_router(snapshot.router, prefix="/api/snapshot", tags=["snapshot"])
 app.include_router(ucache.router, prefix="/api/ucache", tags=["ucache"])
-app.include_router(deposits.router, prefix="/api/deposits", tags=["deposits"])
+app.include_router(deposits_api.router, prefix="/api/deposits", tags=["deposits"])
 app.include_router(pnl.router, prefix="/api/pnl", tags=["pnl"])
 app.include_router(vaults.router, prefix="/api/vaults", tags=["vaults"])
 app.include_router(positions.router, prefix="/api/positions", tags=["positions"])

images/pacman.gif

@@ -10,9 +10,9 @@
 from lib.page import header, needs_backend, sidebar
 from page.asset_liability import asset_liab_matrix_cached_page
 from page.backend import backend_page
-from page.deposits import deposits_page
+from page.deposits_page import deposits_page
 from page.health import health_page
-from page.liquidation_curves import liquidation_curves_page
+from page.liquidation_curves_page import liquidation_curves_page
 from page.market_inspector import market_inspector_page
 from page.orderbook import orderbook_page
 from page.pnl import pnl_page

src/main.py

@@ -1,15 +1,25 @@
 import pandas as pd
 import streamlit as st
 import logging
+import time
 from typing import Optional
 from driftpy.constants.spot_markets import mainnet_spot_market_configs
 
 from lib.api import fetch_api_data
+from src.utils import get_current_slot
 
 # Configure logging
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
 
+def is_processing(result):
+    """Checks if the API result indicates backend processing."""
+    return isinstance(result, dict) and result.get("result") == "processing"
+
+def has_error(result):
+    """Checks if the API result indicates an error."""
+    return isinstance(result, dict) and "error" in result
+
 def format_authority(authority: str) -> str:
     """Format authority to show first and last 4 chars"""
     return f"{authority[:4]}...{authority[-4:]}"
@@ -42,6 +52,9 @@ def get_market_symbol(market_index: int) -> str:
 
 def deposits_page():
     try:
+        # Explicitly type hint as DataFrame
+        df: pd.DataFrame = pd.DataFrame()
+        
         params = st.query_params
         market_index = int(params.get("market_index", 0))
 
@@ -87,11 +100,27 @@ def deposits_page():
                 retry=True,
             )
 
+        if is_processing(result):
+            st.info("Backend is initializing data. Please wait.")
+            with st.spinner("Auto-refreshing in 10 seconds..."):
+                time.sleep(10)
+            st.rerun()
+            return
+            
+        if has_error(result):
+            st.error(f"An error occurred: {result.get('error', 'Unknown error')}")
+            return
+            
         if result is None:
             logger.error("API returned no deposits data")
             st.error("No deposits found")
             return
 
+        slot = result.get("slot", 0)
+        current_slot = get_current_slot()
+        slot_age = current_slot - slot
+        st.info(f"Data from slot {slot}, which is {slot_age} slots old.")
+
         df = pd.DataFrame(result["deposits"])
         if df.empty:
             logger.warning("Empty deposits dataframe created")
@@ -104,7 +133,7 @@ def deposits_page():
 
         if exclude_vaults:
             original_len = len(df)
-            df = df[~df["authority"].isin(result["vaults"])]
+            df = df.loc[~df["authority"].isin(result["vaults"])]
             logger.info(f"Excluded {original_len - len(df)} vault entries")
 
         with col1:
@@ -119,7 +148,7 @@ def deposits_page():
         tabs = st.tabs(["By Position", "By Authority"])
 
         with tabs[0]:
-            filtered_df = df[df["balance"] >= min_balance]
+            filtered_df: pd.DataFrame = df.loc[df["balance"] >= min_balance].copy()
             st.write(f"Total deposits value: **${filtered_df['value'].sum():,.2f}**")
             st.write(f"Number of depositor user accounts: **{len(filtered_df):,}**")
 
@@ -133,7 +162,8 @@ def deposits_page():
             )
 
             # Safely map market indices to symbols
-            filtered_df["market_index"] = filtered_df["market_index"].map(get_market_symbol)
+            if not filtered_df.empty:
+                filtered_df["market_index"] = filtered_df["market_index"].map(get_market_symbol)
 
             st.dataframe(
                 filtered_df.sort_values("value", ascending=False),
@@ -164,7 +194,7 @@ def deposits_page():
                 .agg({"value": "sum", "balance": "sum", "user_account": "count"})
                 .reset_index()
             )
-            grouped_df = grouped_df[grouped_df["value"] >= min_balance]
+            grouped_df: pd.DataFrame = grouped_df.loc[grouped_df["value"] >= min_balance].copy()
             st.write(f"Total deposits value: **${grouped_df['value'].sum():,.2f}**")
             st.write(f"Total number of authorities with deposits: **{len(grouped_df):,}**")
             grouped_df = grouped_df.rename(columns={"user_account": "num_accounts"})

src/page/deposits.py renamed to src/page/deposits_page.py

@@ -381,8 +381,7 @@ def health_page():
                 )
 
             # Check if there are any error messages in the data
-            has_errors = 'Error' in levered_spot_df.columns and levered_spot_df['Error'].any()
-            if has_errors:
+            if 'Error' in levered_spot_df.columns:
                 error_records = levered_spot_df[levered_spot_df['Error'].notna() & (levered_spot_df['Error'] != '')]
                 if not error_records.empty:
                     st.warning(f"Found {len(error_records)} positions with errors. Please check with the team.")