Files

DiTus 19f920bb53 integrated binance checking market

2025-08-04 21:34:08 +02:00

7.4 KiB

Raw Permalink Blame History

Binance API Integration Documentation

Overview

This document describes the Binance API integration added to the FlexTrade hedge trading system. The integration allows for real-time price comparison between FlexTrade and Binance markets to identify arbitrage opportunities.

Features Added

1. Binance Price Fetching

Real-time price fetching from Binance Public API
Support for 12 major cryptocurrency pairs (USDC-based)
Automatic retry and error handling
Rate limiting protection (0.1s delays between requests)

2. Market Mapping

FlexTrade markets are mapped to corresponding Binance symbols:

ETHUSD   → ETHUSDC
BTCUSD   → BTCUSDC
BNBUSD   → BNBUSDC
SOLUSD   → SOLUSDC
DOGEUSD  → DOGEUSDC
AAVEUSD  → AAVEUSDC
ADAUSD   → ADAUSDC
TRXUSD   → TRXUSDC
AVAXUSD  → AVAXUSDC
UNIUSD   → UNIUSDC
LINKUSD  → LINKUSDC
XRPUSD   → XRPUSDC

3. Price Comparison Engine

Side-by-side price comparison between FlexTrade and Binance
Percentage difference calculations
Visual comparison output with emojis (📈📉➡️)
Identification of platform-exclusive prices

4. Arbitrage Opportunity Detection

Automatic detection of price differences above configurable threshold
Potential profit percentage calculations
Recommendation of optimal trading direction
Sorting by profitability (highest opportunities first)

New Functions Added

Core Binance Functions

get_binance_price(symbol, debug=False)
# Fetch single price from Binance API

get_all_binance_prices(debug=False)
# Fetch all mapped cryptocurrency prices

compare_prices(flextrade_prices, binance_prices, debug=False)
# Compare prices between platforms

Utility Functions

get_binance_price_for_market(market_name)
# Get Binance price for specific FlexTrade market

get_price_comparison(market_name)
# Get comparison data for specific market

get_all_price_comparisons()
# Get all comparison results

get_market_arbitrage_opportunities(min_percentage_diff=0.5)
# Find arbitrage opportunities above threshold

Integration Points

1. Enhanced market.py

market_info() function now includes Binance data collection
market_info_loop() supports include_binance parameter
Global latest_prices dictionary stores both FlexTrade and Binance data
Automatic price comparison in each monitoring cycle

2. Updated app.py

Enhanced imports to include Binance functions
start_market_data_thread() supports Binance integration
Main monitoring loop displays arbitrage opportunities
Market tracking statistics show both FlexTrade and Binance counts

Data Storage Structure

Enhanced Global Storage

latest_prices = {
    # FlexTrade prices
    "SOLUSD": {
        'price': 166.37,
        'timestamp': datetime_obj,
        'timestamp_str': "2025-08-04 21:11:22",
        'source': 'flextrade'
    },
    
    # Binance prices
    "SOLUSD_BINANCE": {
        'price': 166.40,
        'binance_symbol': 'SOLUSDC',
        'timestamp': datetime_obj,
        'timestamp_str': "2025-08-04 21:11:37",
        'source': 'binance'
    },
    
    # Comparison results
    '_comparison': {
        'timestamp': datetime_obj,
        'results': {
            'SOLUSD': {
                'flextrade_price': 166.37,
                'binance_price': 166.40,
                'difference': -0.03,
                'difference_pct': -0.018,
                'flextrade_timestamp': "2025-08-04 21:11:22",
                'binance_timestamp': "2025-08-04 21:11:37"
            }
        }
    }
}

Configuration

API Settings

BINANCE_API_BASE_URL = "https://api.binance.com"

Market Mapping

Market mapping can be customized by modifying FLEXTRADE_TO_BINANCE_MAPPING dictionary.

Rate Limiting

0.1 second delay between Binance API calls
15 second delay in FlexTrade data collection (existing)
10 second timeout for HTTP requests

Usage Examples

1. Basic Price Fetching

from market import get_binance_price

# Get SOL price from Binance
sol_price = get_binance_price("SOLUSDC", debug=True)
print(f"SOL/USDC: ${sol_price:.4f}")

2. Find Arbitrage Opportunities

from market import get_market_arbitrage_opportunities

# Find opportunities with >0.5% price difference
opportunities = get_market_arbitrage_opportunities(min_percentage_diff=0.5)

for op in opportunities:
    print(f"{op['market']}: {op['potential_profit_pct']:.2f}% profit potential")
    print(f"Action: {op['action']}")

3. Compare Specific Market

from market import get_price_comparison

# Compare SOL prices
comparison = get_price_comparison("SOLUSD")
if comparison:
    print(f"FlexTrade: ${comparison['flextrade_price']:.4f}")
    print(f"Binance: ${comparison['binance_price']:.4f}")
    print(f"Difference: {comparison['difference_pct']:.2f}%")

Monitoring Output Example

🎯 Found 3 arbitrage opportunities (>0.5% difference):
  1. 📈 ETHUSD: 1.69% potential profit
     FlexTrade: $3743.6852 | Binance: $3681.3200
  2. 📈 ADAUSD: 1.96% potential profit
     FlexTrade: $0.7608 | Binance: $0.7462
  3. 📈 BNBUSD: 1.81% potential profit
     FlexTrade: $777.6834 | Binance: $763.8300

Testing

Test Script: `test_binance.py`

Comprehensive test suite covering:

Single price fetching
Bulk price fetching
Price comparison simulation
Error handling validation

Running Tests

python test_binance.py

Error Handling

Robust Error Management

Network errors: Automatic retry with delays
API rate limiting: Built-in delays and retry logic
Invalid responses: Graceful handling with logging
Missing data: Continues operation with available data
Timeout protection: 10-second request timeouts

Debug Logging

All functions support debug=True parameter for detailed logging:

API request/response details
Error messages with context
Timing information
Rate limiting notifications

Performance Considerations

Efficiency Optimizations

Batch processing: All Binance prices fetched in single cycle
Minimal delays: Only 0.1s between API calls
Background processing: Non-blocking data collection
Memory efficient: Reuses data structures
Selective updates: Only processes markets with both sources

Resource Usage

Network: ~12 API calls per cycle to Binance
Memory: ~50KB additional data storage
CPU: Minimal overhead (~1% additional processing)
Latency: ~2 seconds additional per monitoring cycle

Future Enhancements

Potential Improvements

WebSocket Integration: Real-time Binance price streams
Additional Exchanges: Coinbase, Kraken, Uniswap integration
Historical Data: Price trend analysis and prediction
Automated Trading: Automatic arbitrage execution
Alert System: Price difference notifications
Advanced Analytics: Volatility and correlation analysis

7.4 KiB Raw Permalink Blame History