Add API base URL and enhance error handling

.streamlit/secrets.toml

@@ -1,6 +1,7 @@
 # API Credentials
-GATE_API_KEY = "your_api_key_here"
-GATE_API_SECRET = "your_api_secret_here"
+GATE_API_KEY = "4efbe203fbac0e4bcd0003a0910c801b"
+GATE_API_SECRET = "8b0e9cf47fdd97f2a42bca571a74105c53a5f906cd4ada125938d05115d063a0"
+GATE_API_BASE = "https://api.gate.io/api/v4"
 
 # Theme Configuration
 [theme]

gate_tracker.py

@@ -1 +1,213 @@
- 
+import streamlit as st
+import ccxt
+import pandas as pd
+import numpy as np
+import time
+from datetime import datetime
+import os
+from dotenv import load_dotenv
+from rich.console import Console
+
+# Set page config
+st.set_page_config(
+    page_title="Gate.io Market Making Dashboard",
+    page_icon="📊",
+    layout="wide",
+    initial_sidebar_state="expanded"
+)
+
+# Custom CSS for enhanced neumorphism
+st.markdown("""
+<style>
+    .stApp {
+        background: linear-gradient(145deg, #1a1a1a, #2d2d2d);
+        color: #ffffff;
+    }
+    .stButton>button {
+        background: linear-gradient(145deg, #ff6b00, #ff8533);
+        border: none;
+        border-radius: 10px;
+        box-shadow: 5px 5px 10px rgba(0,0,0,0.3),
+                   -5px -5px 10px rgba(255,255,255,0.1);
+        color: white;
+        padding: 10px 20px;
+        transition: all 0.3s ease;
+    }
+    .stButton>button:hover {
+        transform: translateY(-2px);
+        box-shadow: 6px 6px 12px rgba(0,0,0,0.4),
+                   -6px -6px 12px rgba(255,255,255,0.15);
+    }
+    .stSelectbox>div>div>select {
+        background: linear-gradient(145deg, #2d2d2d, #1a1a1a);
+        color: white;
+        border-radius: 10px;
+        box-shadow: inset 3px 3px 6px rgba(0,0,0,0.3),
+                   inset -3px -3px 6px rgba(255,255,255,0.1);
+    }
+    .stSlider>div>div>div {
+        background: linear-gradient(145deg, #ff6b00, #ff8533);
+    }
+    .stMarkdown {
+        color: #ffffff;
+    }
+    .stDataFrame {
+        background: linear-gradient(145deg, #2d2d2d, #1a1a1a);
+        border-radius: 15px;
+        padding: 20px;
+        box-shadow: 5px 5px 10px rgba(0,0,0,0.3),
+                   -5px -5px 10px rgba(255,255,255,0.1);
+    }
+    .error-message {
+        color: #ff4444;
+        background: rgba(255,68,68,0.1);
+        padding: 10px;
+        border-radius: 10px;
+        margin: 10px 0;
+    }
+</style>
+""", unsafe_allow_html=True)
+
+# Load environment variables
+load_dotenv()
+
+# Initialize Gate.io exchange
+try:
+    exchange = ccxt.gateio({
+        'apiKey': st.secrets["GATE_API_KEY"],
+        'secret': st.secrets["GATE_API_SECRET"],
+        'enableRateLimit': True,
+        'options': {
+            'defaultType': 'swap',
+            'defaultSettle': 'usdt',
+        },
+        'urls': {
+            'api': {
+                'rest': st.secrets["GATE_API_BASE"]
+            }
+        }
+    })
+    
+    # Test API connection
+    exchange.load_markets()
+    st.success("✅ Successfully connected to Gate.io API")
+except Exception as e:
+    st.error(f"❌ Failed to connect to Gate.io API: {str(e)}")
+    st.stop()
+
+st.title("Gate.io Futures Live Data")
+
+# Position Control Parameters
+col1, col2, col3 = st.columns(3)
+
+with col1:
+    min_spread = st.slider("Minimum Spread %", 0.3, 5.0, 0.5, 0.1)
+    min_volume = st.slider("Minimum 24h Volume (USDT)", 100000, 1000000, 200000, 10000)
+    
+with col2:
+    max_positions = st.slider("Max Active Positions", 1, 10, 3, 1)
+    dca_multiplier = st.slider("DCA Size Multiplier", 1.0, 5.0, 2.0, 0.5)
+    
+with col3:
+    hedge_ratio = st.slider("Hedge Ratio", 0.5, 2.0, 1.0, 0.1)
+    leverage = st.slider("Leverage", 1, 10, 3, 1)
+
+def fetch_market_data():
+    try:
+        markets = exchange.load_markets()
+        usdt_pairs = [symbol for symbol in markets.keys() 
+                     if "/USDT" in symbol and markets[symbol].get("type") == "swap"]
+        
+        data = []
+        for symbol in usdt_pairs:
+            try:
+                ticker = exchange.fetch_ticker(symbol)
+                price = ticker['last']
+                volume_24h = ticker['quoteVolume']
+                
+                orderbook = exchange.fetch_order_book(symbol)
+                if orderbook['asks'] and orderbook['bids']:
+                    spread = orderbook['asks'][0][0] - orderbook['bids'][0][0]
+                    spread_pct = (spread / price) * 100
+                    
+                    # Calculate liquidity metrics
+                    bid_depth = sum(bid[1] for bid in orderbook['bids'][:5])
+                    ask_depth = sum(ask[1] for ask in orderbook['asks'][:5])
+                    total_depth = bid_depth + ask_depth
+                    
+                    # Calculate volatility
+                    ohlcv = exchange.fetch_ohlcv(symbol, timeframe='1h', limit=24)
+                    if len(ohlcv) > 0:
+                        prices = [x[4] for x in ohlcv]  # Close prices
+                        volatility = np.std(prices) / np.mean(prices) * 100
+                    else:
+                        volatility = 0
+                    
+                    # Calculate market making score (0-100)
+                    spread_score = max(0, 100 - (spread_pct * 20))  # Lower spread = higher score
+                    volume_score = min(100, volume_24h / min_volume * 100)  # Higher volume = higher score
+                    depth_score = min(100, total_depth / 100)  # Higher depth = higher score
+                    volatility_score = max(0, 100 - (volatility * 10))  # Lower volatility = higher score
+                    
+                    mm_score = (spread_score + volume_score + depth_score + volatility_score) / 4
+                    
+                    if volume_24h >= min_volume and spread_pct >= min_spread:
+                        data.append({
+                            'Symbol': symbol,
+                            'Price': price,
+                            'Spread %': spread_pct,
+                            '24h Volume (USDT)': volume_24h,
+                            'Total Depth': total_depth,
+                            'Volatility %': volatility,
+                            'MM Score': mm_score
+                        })
+            except Exception as e:
+                st.error(f"Error fetching data for {symbol}: {str(e)}")
+                continue
+        
+        if not data:
+            st.warning("No market data available matching the criteria")
+            return None
+            
+        df = pd.DataFrame(data)
+        df = df.dropna()
+        return df
+        
+    except Exception as e:
+        st.error(f"Error fetching market data: {str(e)}")
+        return None
+
+# Create containers for tables
+spread_container = st.empty()
+position_container = st.empty()
+
+while True:
+    try:
+        df = fetch_market_data()
+        
+        if df is not None and not df.empty:
+            # Sort by market making score (highest first)
+            df_sorted = df.sort_values(by='MM Score', ascending=False)
+            
+            # Update spread data
+            with spread_container.container():
+                st.markdown("### 📈 Best Market Making Opportunities")
+                st.dataframe(
+                    df_sorted[['Symbol', 'Price', 'Spread %', '24h Volume (USDT)', 'MM Score']].head(33),
+                    use_container_width=True
+                )
+            
+            # Update position data
+            with position_container.container():
+                st.markdown("### 💰 Active Positions")
+                st.dataframe(
+                    df_sorted[['Symbol', 'Price', 'Spread %', 'Total Depth', 'Volatility %']].head(max_positions),
+                    use_container_width=True
+                )
+        
+        time.sleep(3)  # Update every 3 seconds
+        
+    except Exception as e:
+        st.error(f"Error in main loop: {str(e)}")
+        time.sleep(3)
+        continue