6 posts tagged with "Cryptocurrency"

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)

# Python
import ccxt

# Khởi tạo sàn Binance
binance = ccxt.binance({
    'apiKey': 'YOUR_API_KEY',
    'secret': 'YOUR_SECRET_KEY',
    'enableRateLimit': True,  # Tự động xử lý rate limit
    'options': {
        'defaultType': 'spot',  # Loại giao dịch mặc định
        'adjustForTimeDifference': True  # Tự động điều chỉnh thời gian
    }
})

# Khởi tạo nhiều sàn cùng lúc
exchanges = {
    'binance': ccxt.binance(),
    'kraken': ccxt.kraken(),
    'bitfinex': ccxt.bitfinex()
}

# Lấy danh sách các cặp giao dịch
markets = binance.load_markets()
print(f"Số lượng cặp giao dịch: {len(markets)}")

# Lấy giá hiện tại
ticker = binance.fetch_ticker('BTC/USDT')
print(f"Giá BTC/USDT: {ticker['last']}")

# Lấy order book
orderbook = binance.fetch_order_book('BTC/USDT', limit=5)
print("Bids (Lệnh mua):")
for bid in orderbook['bids']:
    print(f"Giá: {bid[0]}, Số lượng: {bid[1]}")

# Lấy lịch sử giao dịch
trades = binance.fetch_trades('BTC/USDT', limit=5)
for trade in trades:
    print(f"Thời gian: {trade['datetime']}")
    print(f"Giá: {trade['price']}")
    print(f"Số lượng: {trade['amount']}")
    print(f"Loại: {'Mua' if trade['side'] == 'buy' else 'Bán'}")

# Lấy thông tin tài khoản
balance = binance.fetch_balance()
print("Số dư tài khoản:")
for currency, amount in balance['total'].items():
    if amount > 0:
        print(f"{currency}: {amount}")

# Lấy lịch sử giao dịch
orders = binance.fetch_orders('BTC/USDT', limit=5)
for order in orders:
    print(f"ID: {order['id']}")
    print(f"Loại: {order['type']}")
    print(f"Trạng thái: {order['status']}")
    print(f"Giá: {order['price']}")
    print(f"Số lượng: {order['amount']}")

# Đặt lệnh thị trường
market_order = binance.create_market_buy_order(
    symbol='BTC/USDT',
    amount=0.001  # Số lượng BTC
)

# Đặt lệnh giới hạn
limit_order = binance.create_limit_buy_order(
    symbol='BTC/USDT',
    amount=0.001,  # Số lượng BTC
    price=30000    # Giá mua
)

# Hủy lệnh
cancel_order = binance.cancel_order(
    order_id='ORDER_ID',
    symbol='BTC/USDT'
)

import pandas as pd
import numpy as np

# Lấy dữ liệu kline/candlestick
ohlcv = binance.fetch_ohlcv('BTC/USDT', '1h', limit=100)

# Chuyển đổi thành DataFrame
df = pd.DataFrame(ohlcv, columns=['timestamp', 'open', 'high', 'low', 'close', 'volume'])
df['timestamp'] = pd.to_datetime(df['timestamp'], unit='ms')

# Tính toán các chỉ báo kỹ thuật
df['SMA20'] = df['close'].rolling(window=20).mean()
df['SMA50'] = df['close'].rolling(window=50).mean()
df['RSI'] = calculate_rsi(df['close'])  # Hàm tính RSI

# Phân tích xu hướng
df['trend'] = np.where(df['SMA20'] > df['SMA50'], 'uptrend', 'downtrend')

def trading_strategy(exchange, symbol):
    while True:
        try:
            # Lấy dữ liệu thị trường
            ticker = exchange.fetch_ticker(symbol)
            current_price = ticker['last']
            
            # Lấy dữ liệu kline
            ohlcv = exchange.fetch_ohlcv(symbol, '1h', limit=100)
            df = pd.DataFrame(ohlcv, columns=['timestamp', 'open', 'high', 'low', 'close', 'volume'])
            
            # Tính toán chỉ báo
            df['SMA20'] = df['close'].rolling(window=20).mean()
            df['SMA50'] = df['close'].rolling(window=50).mean()
            
            # Logic giao dịch
            if df['SMA20'].iloc[-1] > df['SMA50'].iloc[-1]:
                # Tín hiệu mua
                order = exchange.create_market_buy_order(symbol, 0.001)
                print(f"Đã mua: {order}")
            elif df['SMA20'].iloc[-1] < df['SMA50'].iloc[-1]:
                # Tín hiệu bán
                order = exchange.create_market_sell_order(symbol, 0.001)
                print(f"Đã bán: {order}")
            
            # Đợi 1 phút
            time.sleep(60)
            
        except Exception as e:
            print(f"Lỗi: {e}")
            time.sleep(60)

try:
    # Thực hiện request
    ticker = binance.fetch_ticker('BTC/USDT')
except ccxt.NetworkError as e:
    print(f"Lỗi kết nối: {e}")
except ccxt.ExchangeError as e:
    print(f"Lỗi sàn giao dịch: {e}")
except ccxt.AuthenticationError as e:
    print(f"Lỗi xác thực: {e}")
except Exception as e:
    print(f"Lỗi không xác định: {e}")

# Xử lý rate limits
binance.enableRateLimit = True  # Tự động xử lý rate limits
binance.rateLimit = 1000  # Thời gian chờ giữa các request (ms)

import ccxt

# Khởi tạo sàn giao dịch
exchange = ccxt.binance({
    'apiKey': 'YOUR_API_KEY',
    'secret': 'YOUR_SECRET_KEY'
})

# Lấy giá hiện tại
ticker = exchange.fetch_ticker('BTC/USDT')
print(f"Giá BTC/USDT: {ticker['last']}")

# Đặt lệnh mua
order = exchange.create_market_buy_order('BTC/USDT', 0.001)
print(f"Đã đặt lệnh: {order}")

# Ví dụ bot giao dịch với Python
import ccxt
import pandas as pd
import numpy as np
from datetime import datetime

class TradingBot:
    def __init__(self, exchange_id, api_key, secret):
        self.exchange = getattr(ccxt, exchange_id)({
            'apiKey': api_key,
            'secret': secret
        })
        
    def analyze_market(self, symbol):
        # Lấy dữ liệu thị trường
        ohlcv = self.exchange.fetch_ohlcv(symbol, '1h', limit=100)
        df = pd.DataFrame(ohlcv, columns=['timestamp', 'open', 'high', 'low', 'close', 'volume'])
        
        # Tính toán chỉ báo
        df['SMA20'] = df['close'].rolling(window=20).mean()
        df['RSI'] = self.calculate_rsi(df['close'])
        
        return df
        
    def execute_trade(self, symbol, side, amount):
        try:
            if side == 'buy':
                order = self.exchange.create_market_buy_order(symbol, amount)
            else:
                order = self.exchange.create_market_sell_order(symbol, amount)
            return order
        except Exception as e:
            print(f"Lỗi khi thực hiện giao dịch: {e}")
            return None

# Ví dụ sử dụng REST API với Python
import requests
import hmac
import hashlib
import time

class ExchangeAPI:
    def __init__(self, api_key, secret_key, base_url):
        self.api_key = api_key
        self.secret_key = secret_key
        self.base_url = base_url

    def _generate_signature(self, params):
        # Tạo chữ ký cho request
        query_string = '&'.join([f"{k}={v}" for k, v in params.items()])
        signature = hmac.new(
            self.secret_key.encode('utf-8'),
            query_string.encode('utf-8'),
            hashlib.sha256
        ).hexdigest()
        return signature

    def get_ticker(self, symbol):
        # Lấy giá hiện tại
        endpoint = f"/api/v3/ticker/price"
        params = {'symbol': symbol}
        response = requests.get(f"{self.base_url}{endpoint}", params=params)
        return response.json()

    def create_order(self, symbol, side, type, quantity, price=None):
        # Tạo lệnh giao dịch
        endpoint = "/api/v3/order"
        params = {
            'symbol': symbol,
            'side': side,
            'type': type,
            'quantity': quantity,
            'timestamp': int(time.time() * 1000)
        }
        if price:
            params['price'] = price

        params['signature'] = self._generate_signature(params)
        headers = {'X-MBX-APIKEY': self.api_key}
        
        response = requests.post(
            f"{self.base_url}{endpoint}",
            params=params,
            headers=headers
        )
        return response.json()

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

class TradingBot:
    def __init__(self, exchange_id, api_key, secret):
        self.exchange = getattr(ccxt, exchange_id)({
            'apiKey': api_key,
            'secret': secret
        })
        
    def analyze_market(self, symbol):
        # Lấy dữ liệu thị trường
        ohlcv = self.exchange.fetch_ohlcv(symbol, '1h', limit=100)
        df = pd.DataFrame(ohlcv, columns=['timestamp', 'open', 'high', 'low', 'close', 'volume'])
        
        # Tính toán chỉ báo
        df['SMA20'] = df['close'].rolling(window=20).mean()
        df['RSI'] = self.calculate_rsi(df['close'])
        
        return df
        
    def execute_trade(self, symbol, side, amount):
        try:
            if side == 'buy':
                order = self.exchange.create_market_buy_order(symbol, amount)
            else:
                order = self.exchange.create_market_sell_order(symbol, amount)
            return order
        except Exception as e:
            print(f"Lỗi khi thực hiện giao dịch: {e}")
            return None

import requests
import hmac
import hashlib
import time

class ExchangeAPI:
    def __init__(self, api_key, secret_key, base_url):
        self.api_key = api_key
        self.secret_key = secret_key
        self.base_url = base_url

    def _generate_signature(self, params):
        # Tạo chữ ký cho request
        query_string = '&'.join([f"{k}={v}" for k, v in params.items()])
        signature = hmac.new(
            self.secret_key.encode('utf-8'),
            query_string.encode('utf-8'),
            hashlib.sha256
        ).hexdigest()
        return signature

    def get_ticker(self, symbol):
        # Lấy giá hiện tại
        endpoint = f"/api/v3/ticker/price"
        params = {'symbol': symbol}
        response = requests.get(f"{self.base_url}{endpoint}", params=params)
        return response.json()

    def create_order(self, symbol, side, type, quantity, price=None):
        # Tạo lệnh giao dịch
        endpoint = "/api/v3/order"
        params = {
            'symbol': symbol,
            'side': side,
            'type': type,
            'quantity': quantity,
            'timestamp': int(time.time() * 1000)
        }
        if price:
            params['price'] = price

        params['signature'] = self._generate_signature(params)
        headers = {'X-MBX-APIKEY': self.api_key}
        
        response = requests.post(
            f"{self.base_url}{endpoint}",
            params=params,
            headers=headers
        )
        return response.json()