Update dependencies and enhance open interest API functionality

- Bumped `requests` from version 2.32.3 to 2.32.4 and `driftpy` from version 0.8.57 to 0.8.59 in requirements.txt.
- Added a new function `load_markets_from_json` to load market data from a JSON file, improving market data handling.
- Updated the `_get_open_interest_per_authority`, `_get_open_interest_per_account`, and `_get_open_positions_detailed` functions to accept an optional `market_name` parameter, allowing for filtering by market.
- Introduced a new API endpoint `/markets` to return a list of available market names for the dropdown in the frontend.
- Enhanced the open interest page to display total long and short open interest metrics, improving user insights into market positions.

Author: goldhaxx

backend/api/open_interest_api.py

@@ -1,15 +1,39 @@
-from fastapi import APIRouter
+from fastapi import APIRouter, Query
 from driftpy.constants.numeric_constants import PRICE_PRECISION
-from driftpy.constants.config import mainnet_perp_market_configs
+from driftpy.constants.perp_markets import mainnet_perp_market_configs
+from typing import Optional, List
+import json
+import logging
 
 from backend.state import BackendRequest
 
 router = APIRouter()
+logger = logging.getLogger(__name__)
 
-async def _get_open_interest_per_authority(request: BackendRequest) -> dict:
+def load_markets_from_json(file_path: str):
+    """Loads market data from a JSON file and formats it for the API."""
+    try:
+        with open(file_path, 'r') as f:
+            markets_data = json.load(f)
+        
+        # We need a mapping from marketName to marketIndex
+        formatted_markets = {market["marketName"]: market["marketIndex"] for market in markets_data}
+        logger.info(f"Successfully loaded and formatted {len(formatted_markets)} markets from {file_path}")
+        return formatted_markets
+    except Exception as e:
+        logger.error(f"Error loading markets from {file_path}: {e}")
+        return {}
+
+ALL_MARKETS = load_markets_from_json("shared/markets.json")
+
+async def _get_open_interest_per_authority(request: BackendRequest, market_name: Optional[str] = None) -> dict:
     vat = request.state.backend_state.vat
     slot = request.state.backend_state.last_oracle_slot
 
+    selected_market_index = None
+    if market_name and market_name != "All" and market_name in ALL_MARKETS:
+        selected_market_index = ALL_MARKETS[market_name]
+
     oi_per_authority = {} 
 
     for user_data in vat.users.values():
@@ -23,13 +47,18 @@ async def _get_open_interest_per_authority(request: BackendRequest) -> dict:
 
         current_oi_for_authority = oi_per_authority.get(authority, {
             'total_open_interest_usd': 0.0, 
+            'long_oi_usd': 0.0,
+            'short_oi_usd': 0.0,
             'authority': authority
         })
 
         for position in user_account.perp_positions:
             if position.base_asset_amount == 0:
                 continue
 
+            if selected_market_index is not None and position.market_index != selected_market_index:
+                continue
+
             market_index = position.market_index
             oracle_price_data = vat.perp_oracles.get(market_index)
 
@@ -49,6 +78,10 @@ async def _get_open_interest_per_authority(request: BackendRequest) -> dict:
 
                 position_value_usd = (abs(base_asset_amount_val) / (10**decimals)) * oracle_price
                 current_oi_for_authority['total_open_interest_usd'] += position_value_usd
+                if base_asset_amount_val > 0:
+                    current_oi_for_authority['long_oi_usd'] += position_value_usd
+                elif base_asset_amount_val < 0:
+                    current_oi_for_authority['short_oi_usd'] += position_value_usd
             except (TypeError, ValueError) as e:
                 base_val_repr = repr(getattr(position, 'base_asset_amount', 'N/A'))
                 oracle_price_repr = repr(getattr(oracle_price_data, 'price', 'N/A'))
@@ -66,10 +99,14 @@ async def _get_open_interest_per_authority(request: BackendRequest) -> dict:
         "data": result_list, 
     }
 
-async def _get_open_interest_per_account(request: BackendRequest) -> dict:
+async def _get_open_interest_per_account(request: BackendRequest, market_name: Optional[str] = None) -> dict:
     vat = request.state.backend_state.vat
     slot = request.state.backend_state.last_oracle_slot
 
+    selected_market_index = None
+    if market_name and market_name != "All" and market_name in ALL_MARKETS:
+        selected_market_index = ALL_MARKETS[market_name]
+
     oi_per_account = {}
 
     for user_data in vat.users.values(): # user_data is of type UserMapItem (based on health.py it should have user_public_key)
@@ -92,6 +129,9 @@ async def _get_open_interest_per_account(request: BackendRequest) -> dict:
             if position.base_asset_amount == 0:
                 continue
 
+            if selected_market_index is not None and position.market_index != selected_market_index:
+                continue
+
             market_index = position.market_index
             oracle_price_data = vat.perp_oracles.get(market_index)
 
@@ -127,10 +167,14 @@ async def _get_open_interest_per_account(request: BackendRequest) -> dict:
         "data": result_list,
     }
 
-async def _get_open_positions_detailed(request: BackendRequest) -> dict:
+async def _get_open_positions_detailed(request: BackendRequest, market_name: Optional[str] = None) -> dict:
     vat = request.state.backend_state.vat
     slot = request.state.backend_state.last_oracle_slot
 
+    selected_market_index = None
+    if market_name and market_name != "All" and market_name in ALL_MARKETS:
+        selected_market_index = ALL_MARKETS[market_name]
+
     detailed_positions = []
     decimals = 9 # Constant for perpetual markets base asset amount
 
@@ -147,6 +191,9 @@ async def _get_open_positions_detailed(request: BackendRequest) -> dict:
             if position.base_asset_amount == 0:
                 continue
 
+            if selected_market_index is not None and position.market_index != selected_market_index:
+                continue
+
             market_index = position.market_index
             oracle_price_data = vat.perp_oracles.get(market_index)
 
@@ -194,14 +241,21 @@ async def _get_open_positions_detailed(request: BackendRequest) -> dict:
         "data": sorted_positions,
     }
 
+@router.get("/markets", response_model=List[str])
+async def get_available_markets():
+    """Returns a list of available market names for the dropdown."""
+    if not ALL_MARKETS:
+        return ["All"]
+    return ["All"] + sorted(list(ALL_MARKETS.keys()))
+
 @router.get("/per-authority")
-async def get_open_interest_per_authority(request: BackendRequest):
-    return await _get_open_interest_per_authority(request)
+async def get_open_interest_per_authority(request: BackendRequest, market_name: Optional[str] = Query(None, alias="market_name")):
+    return await _get_open_interest_per_authority(request, market_name)
 
 @router.get("/per-account")
-async def get_open_interest_per_account(request: BackendRequest):
-    return await _get_open_interest_per_account(request)
+async def get_open_interest_per_account(request: BackendRequest, market_name: Optional[str] = Query(None, alias="market_name")):
+    return await _get_open_interest_per_account(request, market_name)
 
 @router.get("/detailed-positions")
-async def get_open_positions_detailed(request: BackendRequest):
-    return await _get_open_positions_detailed(request)
+async def get_open_positions_detailed(request: BackendRequest, market_name: Optional[str] = Query(None, alias="market_name")):
+    return await _get_open_positions_detailed(request, market_name)

requirements.txt

@@ -9,10 +9,10 @@ pydantic==2.10.6
 solana==0.36.6
 streamlit==1.42.1
 uvicorn==0.34.0
-requests==2.32.3
+requests==2.32.4
 plotly==6.0.0
 anchorpy==0.21.0
-driftpy==0.8.57
+driftpy==0.8.59
 ccxt==4.2.17
 rich>=10.14.0
 aiofiles==24.1.0

src/page/open_interest_page.py

@@ -16,24 +16,48 @@ def has_error(result):
     # Check if result is None or a dictionary with an error message
     return result is None or (isinstance(result, dict) and result.get("result") == "error")
 
+@st.cache_data(ttl=3600) # Cache for 1 hour
+def get_market_list():
+    """Fetches the list of available markets for the dropdown."""
+    return fetch_api_data(section="open-interest", path="markets", params={"bypass_cache": "true"})
+
 def open_interest_page():
     st.title("Open Interest on Drift")
 
+    market_list = get_market_list()
+    if not isinstance(market_list, list) or not market_list:
+        st.error("Could not fetch the list of markets. Defaulting to 'All'.")
+        market_list = ["All"]
+
+    selected_market = st.selectbox(
+        "Select Market",
+        options=market_list,
+        index=0, # Default to "All"
+        key='oi_market'
+    )
+
     try:
         # --- 1. Fetch all data --- 
+        api_params = {}
+        if selected_market and selected_market != "All":
+            api_params['market_name'] = selected_market
+
         result_authority = fetch_api_data(
             section="open-interest", 
             path="per-authority",
+            params=api_params,
             retry=False # Let the page handle retries via rerun
         )
         result_account = fetch_api_data(
             section="open-interest",
             path="per-account",
+            params=api_params,
             retry=False
         )
         result_detailed = fetch_api_data(
             section="open-interest",
             path="detailed-positions",
+            params=api_params,
             retry=False
         )
 
@@ -96,8 +120,8 @@ def open_interest_page():
                     'authority': 'User Authority',
                     'total_open_interest_usd': 'Total Open Interest (USD)'
                 }, inplace=True)
-                df_authority = df_authority[["User Authority", "Total Open Interest (USD)"]]
-                df_authority["Total Open Interest (USD)"] = df_authority["Total Open Interest (USD)"].apply(lambda x: f"${x:,.2f}")
+                # Keep original numeric column for calculation, create a new one for display
+                df_authority["Total Open Interest (USD) Display"] = df_authority["Total Open Interest (USD)"].apply(lambda x: f"${x:,.2f}")
 
         df_account = pd.DataFrame()
         if data_account:
@@ -108,8 +132,8 @@ def open_interest_page():
                     'authority': 'Authority',
                     'total_open_interest_usd': 'Total Open Interest (USD)'
                 }, inplace=True)
-                df_account = df_account[['User Account', 'Authority', 'Total Open Interest (USD)']]
-                df_account["Total Open Interest (USD)"] = df_account["Total Open Interest (USD)"].apply(lambda x: f"${x:,.2f}")
+                # Create a new column for display
+                df_account["Total Open Interest (USD) Display"] = df_account["Total Open Interest (USD)"].apply(lambda x: f"${x:,.2f}")
 
         df_detailed = pd.DataFrame()
         if data_detailed:
@@ -123,46 +147,66 @@ def open_interest_page():
                     'user_public_key': 'User Account',
                     'authority': 'Authority'
                 }, inplace=True)
-                df_detailed = df_detailed[[
-                    'Market Index', 'Market Symbol', 'Base Asset Amount', 'Notional Value (USD)',
-                    'User Account', 'Authority'
-                ]]
-                df_detailed['Base Asset Amount'] = df_detailed['Base Asset Amount'].apply(lambda x: f"{x:,.4f}")
-                df_detailed['Notional Value (USD)'] = df_detailed['Notional Value (USD)'].apply(lambda x: f"${x:,.2f}")
+                # Create new columns for display
+                df_detailed['Base Asset Amount Display'] = df_detailed['Base Asset Amount'].apply(lambda x: f"{x:,.4f}")
+                df_detailed['Notional Value (USD) Display'] = df_detailed['Notional Value (USD)'].apply(lambda x: f"${x:,.2f}")
 
         # --- 7. Display Layout (Metrics and DataFrames) --- 
         total_oi_usd = 0.0
+        total_long_oi_usd = 0.0
+        total_short_oi_usd = 0.0
         if not df_authority.empty:
              try:
-                # Calculate metric only if df_authority is valid and processed
-                total_oi_usd = df_authority['Total Open Interest (USD)'].str.replace('[$,]','', regex=True).astype(float).sum()
+                # Calculate metric from the original numeric column
+                total_oi_usd = df_authority['Total Open Interest (USD)'].sum()
+                total_long_oi_usd = df_authority['long_oi_usd'].sum()
+                total_short_oi_usd = df_authority['short_oi_usd'].sum()
              except Exception as calc_e:
                  st.warning(f"Could not calculate Total OI metric: {calc_e}")
 
-        col1, col2 = st.columns(2)
+        col1, col2, col3, col4 = st.columns(4)
         with col1:
             st.metric("Total Authorities with Open Interest", len(df_authority) if not df_authority.empty else 0)
         with col2:
             st.metric("Total Open Interest (USD)", f"${total_oi_usd:,.2f}")
+        with col3:
+            st.metric("Total Long OI (USD)", f"${total_long_oi_usd:,.2f}")
+        with col4:
+            st.metric("Total Short OI (USD)", f"${total_short_oi_usd:,.2f}")
 
         col3, col4 = st.columns(2)
         with col3:
             st.subheader("OI by Authority")
             if not df_authority.empty:
-                st.dataframe(df_authority, hide_index=True)
+                # Display only the relevant columns
+                df_authority_display = df_authority[["User Authority", "Total Open Interest (USD) Display"]]
+                df_authority_display.columns = ["User Authority", "Total Open Interest (USD)"]
+                st.dataframe(df_authority_display, hide_index=True)
             else:
                 st.info("Authority data not available or empty.")
 
         with col4:
             st.subheader("OI by Account")
             if not df_account.empty:
-                st.dataframe(df_account, hide_index=True)
+                # Display only the relevant columns
+                df_account_display = df_account[['User Account', 'Authority', 'Total Open Interest (USD) Display']]
+                df_account_display.columns = ['User Account', 'Authority', 'Total Open Interest (USD)']
+                st.dataframe(df_account_display, hide_index=True)
             else:
                 st.info("Account data not available or empty.")
 
         st.subheader("Detailed Open Positions")
         if not df_detailed.empty:
-            st.dataframe(df_detailed, hide_index=True, use_container_width=True)
+            # Display only the relevant columns
+            df_detailed_display = df_detailed[[
+                'Market Index', 'Market Symbol', 'Base Asset Amount Display', 'Notional Value (USD) Display',
+                'User Account', 'Authority'
+            ]]
+            df_detailed_display.columns = [
+                'Market Index', 'Market Symbol', 'Base Asset Amount', 'Notional Value (USD)',
+                'User Account', 'Authority'
+            ]
+            st.dataframe(df_detailed_display, hide_index=True, use_container_width=True)
         else:
             st.info("Detailed position data not available or empty.")