Adding fees inclusion

app.py

@@ -2,26 +2,51 @@ import gradio as gr
 import asyncio
 from triangular_arbitrage import detector
 
-async def run_detection_ui(exchange_name):
+async def run_detection_ui(
+    exchange_name,
+    include_fees,
+    use_taker,
+    trade_size_usd,
+    slippage_factor,
+    api_key,
+    api_secret
+):
     try:
-        best_opps, best_profit = await detector.run_detection(
+        best_opps, best_profit, fee_breakdown = await detector.run_detection(
             exchange_name=exchange_name,
             max_cycle=3,  # fixed triangular only
+            include_fees=include_fees,
+            use_taker=use_taker,
+            trade_size_usd=trade_size_usd,
+            slippage_factor=slippage_factor,
+            api_key=api_key if api_key else None,
+            api_secret=api_secret if api_secret else None,
         )
 
         if not best_opps:
             return "No arbitrage opportunity found."
 
         result_lines = []
-        for ticker in best_opps:
+        result_lines.append("## Trading Cycle:")
+        for i, ticker in enumerate(best_opps, 1):
             result_lines.append(
-                f"{ticker.symbol} | price: {ticker.last_price:.8f}"
+                f"{i}. {ticker.symbol} | price: {ticker.last_price:.8f}"
             )
 
-        result_text = "\n".join(result_lines)
-        result_text += f"\n\n**Total cycle profit:** {best_profit:.6f}"
+        result_lines.append("\n## Profit Analysis:")
+        
+        if include_fees and fee_breakdown:
+            result_lines.append(f"**Gross Profit:** {fee_breakdown['gross_profit']*100:.4f}%")
+            result_lines.append(f"**Trading Fees:** {fee_breakdown['total_fees']*100:.4f}% ({fee_breakdown['fee_rate_per_trade']*100:.2f}% per trade)")
+            result_lines.append(f"**Slippage:** {fee_breakdown['total_slippage']*100:.4f}% ({fee_breakdown['slippage_per_trade']*100:.4f}% per trade)")
+            result_lines.append(f"**Net Profit:** {fee_breakdown['net_profit']*100:.4f}%")
+            result_lines.append(f"\n**Net Profit Multiplier:** {best_profit:.8f}")
+        else:
+            result_lines.append(f"**Gross Profit:** {(best_profit - 1)*100:.4f}%")
+            result_lines.append(f"**Profit Multiplier:** {best_profit:.8f}")
+            result_lines.append("\n*Note: Fees and slippage not included. Enable 'Include Fees' to see net profit.*")
 
-        return result_text
+        return "\n".join(result_lines)
 
     except Exception as e:
         return f"Error while scanning: {str(e)}"
@@ -29,24 +54,71 @@ async def run_detection_ui(exchange_name):
 
 with gr.Blocks(title="Triangular Arbitrage Scanner") as demo:
     gr.Markdown("# Triangular Arbitrage Scanner")
+    gr.Markdown("Scan for triangular arbitrage opportunities with fee and slippage calculations.")
 
-    exchange = gr.Dropdown(
-        choices=[
-            "binanceus",   # safer default for Spaces
-            # "kraken",
-            # "bitget",
-            # "bybit",
-            # "okx",
-            # "coinbase",
-            # "kucoin",
-            # "gateio",
-            "huobi",
-        ],
-        value="kraken",
-        label="Exchange",
-    )
+    with gr.Row():
+        with gr.Column():
+            exchange = gr.Dropdown(
+                choices=[
+                    "binanceus",
+                    "binance",
+                    "huobi",
+                    "htx",
+                ],
+                value="binanceus",
+                label="Exchange",
+            )
+            
+            include_fees = gr.Checkbox(
+                value=True,
+                label="Include Fees & Slippage",
+                info="Calculate net profit after trading fees and slippage"
+            )
+            
+            use_taker = gr.Radio(
+                choices=[("Taker Fees", True), ("Maker Fees", False)],
+                value=True,
+                label="Fee Type",
+                info="Taker fees are typically higher but execute immediately"
+            )
+            
+            trade_size_usd = gr.Slider(
+                minimum=100,
+                maximum=100000,
+                value=1000,
+                step=100,
+                label="Trade Size (USD)",
+                info="Estimated trade size for slippage calculation"
+            )
+            
+            slippage_factor = gr.Slider(
+                minimum=0.0001,
+                maximum=0.002,
+                value=0.0005,
+                step=0.0001,
+                label="Slippage Factor",
+                info="Slippage per $1000 traded (0.0005 = 0.05% per $1000)"
+            )
+        
+        with gr.Column():
+            gr.Markdown("### API Keys (Optional)")
+            gr.Markdown("Provide API keys to fetch your actual fee tier (VIP discounts, etc.)")
+            
+            api_key = gr.Textbox(
+                label="API Key",
+                type="password",
+                placeholder="Enter your API key (optional)",
+                info="Used to fetch your actual fee tier"
+            )
+            
+            api_secret = gr.Textbox(
+                label="API Secret",
+                type="password",
+                placeholder="Enter your API secret (optional)",
+                info="Used to fetch your actual fee tier"
+            )
 
-    scan_btn = gr.Button("Scan for opportunities", variant="primary")
+    scan_btn = gr.Button("Scan for opportunities", variant="primary", size="lg")
 
     output = gr.Markdown(
         value="Select exchange and click **Scan**.",
@@ -55,7 +127,15 @@ with gr.Blocks(title="Triangular Arbitrage Scanner") as demo:
 
     scan_btn.click(
         fn=run_detection_ui,
-        inputs=exchange,
+        inputs=[
+            exchange,
+            include_fees,
+            use_taker,
+            trade_size_usd,
+            slippage_factor,
+            api_key,
+            api_secret
+        ],
         outputs=output,
     )
 

requirements.txt

@@ -1,3 +1,4 @@
 ccxt
 networkx[default]>=3.4, <3.5
-OctoBot-Commons>=1.9, <1.10
+OctoBot-Commons>=1.9, <1.10
+gradio

triangular_arbitrage/detector.py

@@ -1,12 +1,19 @@
 # pylint: disable=W0702, C0325
 
 import ccxt.async_support as ccxt
-from typing import List, Tuple
+from typing import List, Tuple, Optional, Dict
 from dataclasses import dataclass
 import networkx as nx
 
 import octobot_commons.symbols as symbols
 import octobot_commons.constants as constants
+from triangular_arbitrage.fees import (
+    get_exchange_fees,
+    calculate_net_profit,
+    get_fee_breakdown,
+    ExchangeFees,
+    fetch_user_fee_tier
+)
 
 
 @dataclass
@@ -54,7 +61,33 @@ def get_best_triangular_opportunity(tickers: List[ShortTicker]) -> Tuple[List[Sh
     return get_best_opportunity(tickers, 3)
 
 
-def get_best_opportunity(tickers: List[ShortTicker], max_cycle: int = 10) -> Tuple[List[ShortTicker], float]:
+def get_best_opportunity(
+    tickers: List[ShortTicker],
+    max_cycle: int = 10,
+    exchange_fees: Optional[ExchangeFees] = None,
+    use_taker: bool = True,
+    trade_size_usd: float = 1000.0,
+    slippage_factor: float = 0.0005,
+    include_fees: bool = True
+) -> Tuple[List[ShortTicker], float, Optional[Dict[str, float]]]:
+    """
+    Find the best arbitrage opportunity.
+    
+    Args:
+        tickers: List of tickers with prices
+        max_cycle: Maximum cycle length to consider
+        exchange_fees: Exchange fee structure (if None, fees won't be applied)
+        use_taker: Whether to use taker fees (True) or maker fees (False)
+        trade_size_usd: Estimated trade size for slippage calculation
+        slippage_factor: Slippage factor per $1000 traded
+        include_fees: Whether to calculate net profit with fees and slippage
+    
+    Returns:
+        Tuple of (best_cycle, best_profit, fee_breakdown)
+        - best_cycle: List of tickers in the best cycle
+        - best_profit: Best profit multiplier (gross if include_fees=False, net if include_fees=True)
+        - fee_breakdown: Dictionary with fee details (None if include_fees=False)
+    """
     # Build a directed graph of currencies
     graph = nx.DiGraph()
 
@@ -67,25 +100,53 @@ def get_best_opportunity(tickers: List[ShortTicker], max_cycle: int = 10) -> Tup
 
     best_profit = 1
     best_cycle = None
+    best_gross_profit = 1
+    best_fee_breakdown = None
 
     # Find all cycles in the graph with a length <= max_cycle
     for cycle in nx.simple_cycles(graph):
         if len(cycle) > max_cycle:
             continue  # Skip cycles longer than max_cycle
 
-        profit = 1
+        gross_profit = 1
         tickers_in_cycle = []
 
-        # Calculate the profits along the cycle
+        # Calculate the gross profits along the cycle
         for i, base in enumerate(cycle):
             quote = cycle[(i + 1) % len(cycle)]  # Wrap around to complete the cycle
             ticker = graph[base][quote]['ticker']
             tickers_in_cycle.append(ticker)
-            profit *= ticker.last_price
-
-        if profit > best_profit:
-            best_profit = profit
+            gross_profit *= ticker.last_price
+
+        # Calculate net profit if fees should be included
+        if include_fees and exchange_fees is not None:
+            net_profit = calculate_net_profit(
+                gross_profit,
+                exchange_fees,
+                num_trades=len(cycle),
+                use_taker=use_taker,
+                trade_size_usd=trade_size_usd,
+                slippage_factor=slippage_factor
+            )
+            profit_to_compare = net_profit
+        else:
+            profit_to_compare = gross_profit
+
+        if profit_to_compare > best_profit:
+            best_profit = profit_to_compare
+            best_gross_profit = gross_profit
             best_cycle = tickers_in_cycle
+            
+            # Calculate fee breakdown if fees are included
+            if include_fees and exchange_fees is not None:
+                best_fee_breakdown = get_fee_breakdown(
+                    gross_profit,
+                    exchange_fees,
+                    num_trades=len(cycle),
+                    use_taker=use_taker,
+                    trade_size_usd=trade_size_usd,
+                    slippage_factor=slippage_factor
+                )
 
     if best_cycle is not None:
         best_cycle = [
@@ -94,7 +155,7 @@ def get_best_opportunity(tickers: List[ShortTicker], max_cycle: int = 10) -> Tup
             for ticker in best_cycle
         ]
 
-    return best_cycle, best_profit
+    return best_cycle, best_profit, best_fee_breakdown
 
 
 async def get_exchange_data(exchange_name):
@@ -119,8 +180,60 @@ async def get_exchange_last_prices(exchange_name, ignored_symbols, whitelisted_s
     return last_prices
 
 
-async def run_detection(exchange_name, ignored_symbols=None, whitelisted_symbols=None, max_cycle=10):
+async def run_detection(
+    exchange_name,
+    ignored_symbols=None,
+    whitelisted_symbols=None,
+    max_cycle=10,
+    include_fees=True,
+    use_taker=True,
+    trade_size_usd=1000.0,
+    slippage_factor=0.0005,
+    api_key=None,
+    api_secret=None
+):
+    """
+    Run arbitrage detection with optional fee calculation.
+    
+    Args:
+        exchange_name: Name of the exchange
+        ignored_symbols: List of symbols to ignore
+        whitelisted_symbols: List of symbols to include (None = all)
+        max_cycle: Maximum cycle length
+        include_fees: Whether to include fees and slippage in profit calculation
+        use_taker: Whether to use taker fees (True) or maker fees (False)
+        trade_size_usd: Estimated trade size for slippage calculation
+        slippage_factor: Slippage factor per $1000 traded
+        api_key: Optional API key for fetching actual fee tiers
+        api_secret: Optional API secret for fetching actual fee tiers
+    
+    Returns:
+        Tuple of (best_opportunity, best_profit, fee_breakdown)
+    """
     last_prices = await get_exchange_last_prices(exchange_name, ignored_symbols or [], whitelisted_symbols)
-    # default is the best opportunity for all cycles
-    best_opportunity, best_profit = get_best_opportunity(last_prices, max_cycle=max_cycle)
-    return best_opportunity, best_profit
+    
+    # Get exchange fees
+    exchange_fees = None
+    if include_fees:
+        # Try to fetch user-specific fees if API keys are provided
+        if api_key and api_secret:
+            user_fees = await fetch_user_fee_tier(exchange_name, api_key, api_secret)
+            if user_fees:
+                exchange_fees = user_fees
+        
+        # Fall back to standard fees
+        if exchange_fees is None:
+            exchange_fees = get_exchange_fees(exchange_name)
+    
+    # Find best opportunity with fees
+    best_opportunity, best_profit, fee_breakdown = get_best_opportunity(
+        last_prices,
+        max_cycle=max_cycle,
+        exchange_fees=exchange_fees,
+        use_taker=use_taker,
+        trade_size_usd=trade_size_usd,
+        slippage_factor=slippage_factor,
+        include_fees=include_fees
+    )
+    
+    return best_opportunity, best_profit, fee_breakdown

triangular_arbitrage/fees.py

@@ -0,0 +1,300 @@
+"""
+Fee calculation module for triangular arbitrage.
+Handles trading fees (maker/taker) and slippage for different exchanges.
+"""
+
+from typing import Optional, Dict
+from dataclasses import dataclass
+import ccxt.async_support as ccxt
+
+
+@dataclass
+class ExchangeFees:
+    """Fee structure for an exchange."""
+    maker_fee: float  # Maker fee as decimal (e.g., 0.001 for 0.1%)
+    taker_fee: float  # Taker fee as decimal (e.g., 0.001 for 0.1%)
+    name: str
+
+
+# Standard fee structures for exchanges
+EXCHANGE_FEES: Dict[str, ExchangeFees] = {
+    "binance": ExchangeFees(
+        maker_fee=0.001,  # 0.1%
+        taker_fee=0.001,  # 0.1%
+        name="Binance"
+    ),
+    "binanceus": ExchangeFees(
+        maker_fee=0.001,  # 0.1%
+        taker_fee=0.001,  # 0.1%
+        name="Binance US"
+    ),
+    "huobi": ExchangeFees(
+        maker_fee=0.002,  # 0.2%
+        taker_fee=0.002,  # 0.2%
+        name="Huobi"
+    ),
+    "htx": ExchangeFees(  # Huobi rebranded as HTX
+        maker_fee=0.002,  # 0.2%
+        taker_fee=0.002,  # 0.2%
+        name="HTX"
+    ),
+}
+
+
+def get_exchange_fees(exchange_name: str) -> ExchangeFees:
+    """
+    Get fee structure for an exchange.
+    
+    Args:
+        exchange_name: Name of the exchange (e.g., 'binance', 'huobi')
+    
+    Returns:
+        ExchangeFees object with maker and taker fees
+    """
+    # Normalize exchange name
+    exchange_name_lower = exchange_name.lower()
+    
+    # Check direct match
+    if exchange_name_lower in EXCHANGE_FEES:
+        return EXCHANGE_FEES[exchange_name_lower]
+    
+    # Check partial matches
+    for key, fees in EXCHANGE_FEES.items():
+        if key in exchange_name_lower or exchange_name_lower in key:
+            return fees
+    
+    # Default fees (conservative estimate)
+    return ExchangeFees(
+        maker_fee=0.002,  # 0.2% default
+        taker_fee=0.002,  # 0.2% default
+        name=exchange_name
+    )
+
+
+async def fetch_user_fee_tier(
+    exchange_name: str,
+    api_key: Optional[str] = None,
+    api_secret: Optional[str] = None
+) -> Optional[ExchangeFees]:
+    """
+    Fetch actual fee tier from exchange API if API keys are provided.
+    This allows for VIP tier discounts and BNB/HT holdings discounts.
+    
+    Args:
+        exchange_name: Name of the exchange
+        api_key: API key for authenticated requests
+        api_secret: API secret for authenticated requests
+    
+    Returns:
+        ExchangeFees with actual user fees, or None if not available
+    """
+    if not api_key or not api_secret:
+        return None
+    
+    try:
+        exchange_class = getattr(ccxt, exchange_name)
+        exchange = exchange_class({
+            'apiKey': api_key,
+            'secret': api_secret,
+            'enableRateLimit': True,
+            'options': {
+                'defaultType': 'spot',  # Ensure we're using spot trading
+            }
+        })
+        
+        # Try to fetch fee information
+        exchange_name_lower = exchange_name.lower()
+        
+        if exchange_name_lower in ['binance', 'binanceus']:
+            try:
+                # Binance: fetch trading fees
+                if hasattr(exchange, 'fetch_trading_fees'):
+                    fees = await exchange.fetch_trading_fees()
+                    if fees and 'trading' in fees:
+                        trading_fees = fees['trading']
+                        # Get fees for a common trading pair (e.g., BTC/USDT)
+                        if 'BTC/USDT' in trading_fees:
+                            btc_fees = trading_fees['BTC/USDT']
+                            maker_fee = btc_fees.get('maker', 0.001)
+                            taker_fee = btc_fees.get('taker', 0.001)
+                            await exchange.close()
+                            return ExchangeFees(
+                                maker_fee=maker_fee,
+                                taker_fee=taker_fee,
+                                name=f"{exchange_name} (User Tier)"
+                            )
+                
+                # Alternative: try fetchBalance which sometimes includes fee info
+                balance = await exchange.fetch_balance()
+                if 'info' in balance:
+                    info = balance['info']
+                    # Binance account info might contain fee tier
+                    # This varies by exchange API version
+                    pass
+                    
+            except Exception as e:
+                # If specific method fails, try general approach
+                pass
+        
+        elif exchange_name_lower in ['huobi', 'htx']:
+            try:
+                # Huobi: fetch trading fees
+                if hasattr(exchange, 'fetch_trading_fees'):
+                    fees = await exchange.fetch_trading_fees()
+                    if fees and 'trading' in fees:
+                        trading_fees = fees['trading']
+                        if 'BTC/USDT' in trading_fees:
+                            btc_fees = trading_fees['BTC/USDT']
+                            maker_fee = btc_fees.get('maker', 0.002)
+                            taker_fee = btc_fees.get('taker', 0.002)
+                            await exchange.close()
+                            return ExchangeFees(
+                                maker_fee=maker_fee,
+                                taker_fee=taker_fee,
+                                name=f"{exchange_name} (User Tier)"
+                            )
+            except Exception:
+                pass
+        
+        # Try generic fetchTradingFees if available
+        try:
+            if hasattr(exchange, 'fetch_trading_fees'):
+                fees = await exchange.fetch_trading_fees()
+                if fees:
+                    # Extract maker/taker from first available trading pair
+                    if isinstance(fees, dict) and 'trading' in fees:
+                        trading_fees = fees['trading']
+                        for pair, pair_fees in trading_fees.items():
+                            if isinstance(pair_fees, dict):
+                                maker_fee = pair_fees.get('maker')
+                                taker_fee = pair_fees.get('taker')
+                                if maker_fee is not None and taker_fee is not None:
+                                    await exchange.close()
+                                    return ExchangeFees(
+                                        maker_fee=maker_fee,
+                                        taker_fee=taker_fee,
+                                        name=f"{exchange_name} (User Tier)"
+                                    )
+        except Exception:
+            pass
+        
+        await exchange.close()
+        
+    except Exception:
+        # If fetching fails, return None to use default fees
+        pass
+    
+    return None
+
+
+def calculate_trading_fees(
+    amount: float,
+    fee_rate: float,
+    num_trades: int = 3
+) -> float:
+    """
+    Calculate total trading fees for a triangular arbitrage cycle.
+    
+    Args:
+        amount: Starting amount (e.g., 1.0 for calculating profit ratio)
+        fee_rate: Fee rate per trade (as decimal, e.g., 0.001 for 0.1%)
+        num_trades: Number of trades in the cycle (default 3 for triangular)
+    
+    Returns:
+        Total fees as a multiplier (e.g., 0.003 for 0.3% total fees)
+    """
+    # For triangular arbitrage, we pay fees on each of the 3 trades
+    # Fee is deducted from the amount received, so we multiply by (1 - fee_rate) for each trade
+    return (1 - fee_rate) ** num_trades
+
+
+def calculate_slippage(
+    trade_size_usd: float = 1000.0,
+    liquidity_factor: float = 0.0005  # 0.05% slippage per $1000 traded
+) -> float:
+    """
+    Calculate slippage as a percentage based on trade size and liquidity.
+    
+    Args:
+        trade_size_usd: Estimated trade size in USD (default 1000)
+        liquidity_factor: Slippage factor per $1000 (default 0.0005 = 0.05%)
+                         Higher liquidity = lower slippage
+    
+    Returns:
+        Slippage multiplier (e.g., 0.9995 for 0.05% slippage)
+    """
+    # Slippage increases with trade size
+    # Formula: slippage = 1 - (trade_size / 1000) * liquidity_factor
+    slippage_percentage = min((trade_size_usd / 1000.0) * liquidity_factor, 0.01)  # Cap at 1%
+    return 1 - slippage_percentage
+
+
+def calculate_net_profit(
+    gross_profit: float,
+    exchange_fees: ExchangeFees,
+    num_trades: int = 3,
+    use_taker: bool = True,
+    trade_size_usd: float = 1000.0,
+    slippage_factor: float = 0.0005
+) -> float:
+    """
+    Calculate net profit after fees and slippage.
+    
+    Args:
+        gross_profit: Gross profit multiplier (e.g., 1.002 for 0.2% profit)
+        exchange_fees: ExchangeFees object with maker/taker rates
+        num_trades: Number of trades in the cycle (default 3)
+        use_taker: Whether to use taker fees (True) or maker fees (False)
+        trade_size_usd: Estimated trade size for slippage calculation
+        slippage_factor: Slippage factor per $1000 traded
+    
+    Returns:
+        Net profit multiplier after fees and slippage
+    """
+    # Select appropriate fee rate
+    fee_rate = exchange_fees.taker_fee if use_taker else exchange_fees.maker_fee
+    
+    # Calculate fee impact
+    fee_multiplier = calculate_trading_fees(1.0, fee_rate, num_trades)
+    
+    # Calculate slippage impact (applied to each trade)
+    slippage_per_trade = calculate_slippage(trade_size_usd, slippage_factor)
+    slippage_multiplier = slippage_per_trade ** num_trades
+    
+    # Net profit = gross profit * fee multiplier * slippage multiplier
+    net_profit = gross_profit * fee_multiplier * slippage_multiplier
+    
+    return net_profit
+
+
+def get_fee_breakdown(
+    gross_profit: float,
+    exchange_fees: ExchangeFees,
+    num_trades: int = 3,
+    use_taker: bool = True,
+    trade_size_usd: float = 1000.0,
+    slippage_factor: float = 0.0005
+) -> Dict[str, float]:
+    """
+    Get detailed breakdown of fees and slippage.
+    
+    Returns:
+        Dictionary with gross_profit, total_fees, total_slippage, net_profit
+    """
+    fee_rate = exchange_fees.taker_fee if use_taker else exchange_fees.maker_fee
+    fee_multiplier = calculate_trading_fees(1.0, fee_rate, num_trades)
+    slippage_per_trade = calculate_slippage(trade_size_usd, slippage_factor)
+    slippage_multiplier = slippage_per_trade ** num_trades
+    
+    total_fees = 1 - fee_multiplier
+    total_slippage = 1 - slippage_multiplier
+    net_profit = gross_profit * fee_multiplier * slippage_multiplier
+    
+    return {
+        "gross_profit": gross_profit - 1,
+        "total_fees": total_fees,
+        "total_slippage": total_slippage,
+        "net_profit": net_profit - 1,
+        "fee_rate_per_trade": fee_rate,
+        "slippage_per_trade": 1 - slippage_per_trade,
+    }