2 posts tagged with "CCXT"

import ccxt
import pandas as pd
import numpy as np
from datetime import datetime

# Khởi tạo các sàn giao dịch
exchanges = {
    'binance': ccxt.binance(),
    'coinbase': ccxt.coinbase(),
    'kraken': ccxt.kraken(),
    'kucoin': ccxt.kucoin()
}

# Cấu hình chung
for exchange in exchanges.values():
    exchange.enableRateLimit = True

def get_current_prices(symbol, exchanges):
    """
    Lấy giá hiện tại của một cặp giao dịch từ nhiều sàn
    
    Parameters:
    - symbol: Cặp giao dịch (ví dụ: 'BTC/USDT')
    - exchanges: Dictionary chứa các exchange objects
    """
    prices = {}
    for name, exchange in exchanges.items():
        try:
            ticker = exchange.fetch_ticker(symbol)
            prices[name] = {
                'bid': ticker['bid'],
                'ask': ticker['ask'],
                'last': ticker['last'],
                'timestamp': datetime.fromtimestamp(ticker['timestamp']/1000)
            }
        except Exception as e:
            print(f"Error fetching {symbol} from {name}: {e}")
    return prices

# Ví dụ sử dụng
symbol = 'BTC/USDT'
prices = get_current_prices(symbol, exchanges)

def calculate_arbitrage_opportunities(prices):
    """
    Tính toán cơ hội arbitrage giữa các sàn
    """
    opportunities = []
    
    # Tạo ma trận chênh lệch
    exchanges = list(prices.keys())
    for i in range(len(exchanges)):
        for j in range(i+1, len(exchanges)):
            exchange1 = exchanges[i]
            exchange2 = exchanges[j]
            
            # Tính chênh lệch mua-bán
            spread1 = prices[exchange1]['ask'] - prices[exchange2]['bid']
            spread2 = prices[exchange2]['ask'] - prices[exchange1]['bid']
            
            # Tính phần trăm chênh lệch
            spread1_pct = (spread1 / prices[exchange2]['bid']) * 100
            spread2_pct = (spread2 / prices[exchange1]['bid']) * 100
            
            opportunities.append({
                'exchange1': exchange1,
                'exchange2': exchange2,
                'spread1': spread1,
                'spread2': spread2,
                'spread1_pct': spread1_pct,
                'spread2_pct': spread2_pct,
                'timestamp': datetime.now()
            })
    
    return pd.DataFrame(opportunities)

# Tính toán cơ hội arbitrage
arbitrage_df = calculate_arbitrage_opportunities(prices)

def analyze_arbitrage(arbitrage_df, min_spread_pct=0.5):
    """
    Phân tích cơ hội arbitrage
    
    Parameters:
    - arbitrage_df: DataFrame chứa dữ liệu chênh lệch
    - min_spread_pct: Phần trăm chênh lệch tối thiểu để xem xét
    """
    # Lọc các cơ hội có chênh lệch đáng kể
    significant_opportunities = arbitrage_df[
        (arbitrage_df['spread1_pct'] > min_spread_pct) |
        (arbitrage_df['spread2_pct'] > min_spread_pct)
    ]
    
    # Sắp xếp theo chênh lệch
    significant_opportunities = significant_opportunities.sort_values(
        by=['spread1_pct', 'spread2_pct'],
        ascending=False
    )
    
    return significant_opportunities

# Phân tích cơ hội
opportunities = analyze_arbitrage(arbitrage_df)
print(opportunities)

def plot_arbitrage_opportunities(arbitrage_df):
    """
    Vẽ biểu đồ chênh lệch giá
    """
    import plotly.graph_objects as go
    
    # Tạo biểu đồ
    fig = go.Figure()
    
    # Thêm các cột cho spread1 và spread2
    fig.add_trace(go.Bar(
        name='Spread 1',
        x=arbitrage_df['exchange1'] + ' vs ' + arbitrage_df['exchange2'],
        y=arbitrage_df['spread1_pct'],
        text=arbitrage_df['spread1_pct'].round(2),
        textposition='auto',
    ))
    
    fig.add_trace(go.Bar(
        name='Spread 2',
        x=arbitrage_df['exchange1'] + ' vs ' + arbitrage_df['exchange2'],
        y=arbitrage_df['spread2_pct'],
        text=arbitrage_df['spread2_pct'].round(2),
        textposition='auto',
    ))
    
    # Cập nhật layout
    fig.update_layout(
        title='Arbitrage Opportunities Between Exchanges',
        xaxis_title='Exchange Pairs',
        yaxis_title='Spread Percentage (%)',
        barmode='group',
        template='plotly_dark'
    )
    
    return fig

# Vẽ biểu đồ
fig = plot_arbitrage_opportunities(arbitrage_df)
fig.show()

def monitor_arbitrage(symbol, exchanges, interval=60, duration=3600):
    """
    Theo dõi chênh lệch giá theo thời gian thực
    
    Parameters:
    - symbol: Cặp giao dịch
    - exchanges: Dictionary chứa các exchange objects
    - interval: Khoảng thời gian giữa các lần kiểm tra (giây)
    - duration: Thời gian theo dõi (giây)
    """
    import time
    from datetime import datetime, timedelta
    
    end_time = datetime.now() + timedelta(seconds=duration)
    opportunities_history = []
    
    while datetime.now() < end_time:
        try:
            # Lấy giá hiện tại
            prices = get_current_prices(symbol, exchanges)
            
            # Tính toán cơ hội arbitrage
            arbitrage_df = calculate_arbitrage_opportunities(prices)
            
            # Phân tích cơ hội
            opportunities = analyze_arbitrage(arbitrage_df)
            
            # Lưu vào lịch sử
            opportunities_history.append({
                'timestamp': datetime.now(),
                'opportunities': opportunities
            })
            
            # In thông tin
            print(f"\nTime: {datetime.now()}")
            print(opportunities)
            
            # Đợi đến lần kiểm tra tiếp theo
            time.sleep(interval)
            
        except Exception as e:
            print(f"Error in monitoring: {e}")
            time.sleep(interval)
    
    return pd.DataFrame(opportunities_history)

# Bắt đầu theo dõi
# monitor_arbitrage('BTC/USDT', exchanges)

def calculate_potential_profit(opportunity, amount=1.0):
    """
    Tính toán lợi nhuận tiềm năng từ cơ hội arbitrage
    
    Parameters:
    - opportunity: Dictionary chứa thông tin cơ hội arbitrage
    - amount: Số lượng coin giao dịch
    """
    # Tính lợi nhuận cho cả hai hướng
    profit1 = amount * opportunity['spread1']
    profit2 = amount * opportunity['spread2']
    
    # Tính phí giao dịch (ước tính)
    fee_rate = 0.001  # 0.1%
    fees = amount * fee_rate * 2  # Phí mua và bán
    
    # Lợi nhuận thực tế
    net_profit1 = profit1 - fees
    net_profit2 = profit2 - fees
    
    return {
        'gross_profit1': profit1,
        'gross_profit2': profit2,
        'fees': fees,
        'net_profit1': net_profit1,
        'net_profit2': net_profit2
    }

import ccxt
import pandas as pd
import plotly.graph_objects as go
from datetime import datetime

# Khởi tạo exchange
exchange = ccxt.binance({
    'enableRateLimit': True,  # Tự động xử lý rate limit
    'options': {
        'defaultType': 'spot'  # Sử dụng spot trading
    }
})

# Kiểm tra kết nối
print(f"Exchange: {exchange.name}")
print(f"Markets: {len(exchange.markets)}")

def fetch_ohlcv(symbol, timeframe='1h', limit=1000):
    """
    Lấy dữ liệu OHLCV từ Binance
    
    Parameters:
    - symbol: Cặp giao dịch (ví dụ: 'BTC/USDT')
    - timeframe: Khung thời gian ('1m', '5m', '1h', '4h', '1d')
    - limit: Số lượng nến muốn lấy (tối đa 1000)
    """
    try:
        ohlcv = exchange.fetch_ohlcv(symbol, timeframe, limit=limit)
        df = pd.DataFrame(ohlcv, columns=['timestamp', 'open', 'high', 'low', 'close', 'volume'])
        df['timestamp'] = pd.to_datetime(df['timestamp'], unit='ms')
        return df
    except Exception as e:
        print(f"Error fetching data: {e}")
        return None

# Ví dụ sử dụng
btc_data = fetch_ohlcv('BTC/USDT', '1h', 1000)
print(btc_data.head())

def fetch_multiple_ohlcv(symbol, timeframe='1h', since=None, limit=1000):
    """
    Lấy nhiều hơn 1000 nến bằng cách sử dụng since parameter
    """
    all_ohlcv = []
    while True:
        try:
            ohlcv = exchange.fetch_ohlcv(symbol, timeframe, since=since, limit=limit)
            if len(ohlcv) == 0:
                break
            all_ohlcv.extend(ohlcv)
            since = ohlcv[-1][0] + 1
        except Exception as e:
            print(f"Error: {e}")
            break
    return pd.DataFrame(all_ohlcv, columns=['timestamp', 'open', 'high', 'low', 'close', 'volume'])

def process_ohlcv_data(df):
    """
    Xử lý dữ liệu OHLCV
    """
    # Chuyển đổi timestamp
    df['timestamp'] = pd.to_datetime(df['timestamp'], unit='ms')
    
    # Tính toán các chỉ báo
    df['returns'] = df['close'].pct_change()
    df['volatility'] = df['returns'].rolling(window=20).std()
    
    # Tính toán SMA
    df['SMA20'] = df['close'].rolling(window=20).mean()
    df['SMA50'] = df['close'].rolling(window=50).mean()
    
    return df

# Xử lý dữ liệu
btc_data = process_ohlcv_data(btc_data)

def save_data(df, filename, format='csv'):
    """
    Lưu dữ liệu ra file
    """
    if format == 'csv':
        df.to_csv(f"{filename}.csv", index=False)
    elif format == 'excel':
        df.to_excel(f"{filename}.xlsx", index=False)
    elif format == 'html':
        df.to_html(f"{filename}.html", index=False)
    else:
        print("Unsupported format")

# Ví dụ lưu dữ liệu
save_data(btc_data, 'btc_data', 'csv')
save_data(btc_data, 'btc_data', 'excel')

def plot_candlestick(df, title='BTC/USDT Price'):
    """
    Vẽ biểu đồ nến với Plotly
    """
    fig = go.Figure(data=[go.Candlestick(
        x=df['timestamp'],
        open=df['open'],
        high=df['high'],
        low=df['low'],
        close=df['close']
    )])
    
    # Thêm SMA
    fig.add_trace(go.Scatter(
        x=df['timestamp'],
        y=df['SMA20'],
        name='SMA20',
        line=dict(color='blue')
    ))
    
    fig.add_trace(go.Scatter(
        x=df['timestamp'],
        y=df['SMA50'],
        name='SMA50',
        line=dict(color='red')
    ))
    
    # Cập nhật layout
    fig.update_layout(
        title=title,
        yaxis_title='Price (USDT)',
        xaxis_title='Date',
        template='plotly_dark'
    )
    
    return fig

# Vẽ và hiển thị biểu đồ
fig = plot_candlestick(btc_data)
fig.show()

def plot_volume(df, title='BTC/USDT Volume'):
    """
    Vẽ biểu đồ volume
    """
    fig = go.Figure(data=[go.Bar(
        x=df['timestamp'],
        y=df['volume'],
        name='Volume'
    )])
    
    fig.update_layout(
        title=title,
        yaxis_title='Volume',
        xaxis_title='Date',
        template='plotly_dark'
    )
    
    return fig

# Vẽ và hiển thị biểu đồ volume
volume_fig = plot_volume(btc_data)
volume_fig.show()

def get_current_price(symbol):
    """
    Lấy giá hiện tại của một cặp giao dịch
    """
    try:
        ticker = exchange.fetch_ticker(symbol)
        return {
            'symbol': symbol,
            'last': ticker['last'],
            'bid': ticker['bid'],
            'ask': ticker['ask'],
            'volume': ticker['baseVolume'],
            'timestamp': datetime.fromtimestamp(ticker['timestamp']/1000)
        }
    except Exception as e:
        print(f"Error fetching ticker: {e}")
        return None

# Ví dụ lấy giá BTC/USDT
btc_ticker = get_current_price('BTC/USDT')
print(btc_ticker)

def fetch_multiple_symbols(symbols, timeframe='1h', limit=1000):
    """
    Lấy dữ liệu từ nhiều cặp giao dịch
    """
    data = {}
    for symbol in symbols:
        data[symbol] = fetch_ohlcv(symbol, timeframe, limit)
    return data

# Ví dụ lấy dữ liệu nhiều cặp
symbols = ['BTC/USDT', 'ETH/USDT', 'BNB/USDT']
multi_data = fetch_multiple_symbols(symbols)

def calculate_correlation(data_dict):
    """
    Tính toán tương quan giữa các cặp giao dịch
    """
    # Tạo DataFrame với giá đóng cửa của các cặp
    closes = pd.DataFrame()
    for symbol, df in data_dict.items():
        closes[symbol] = df['close']
    
    # Tính toán ma trận tương quan
    correlation = closes.corr()
    return correlation

# Tính và hiển thị tương quan
correlation = calculate_correlation(multi_data)
print(correlation)