6 posts tagged with "Trading"

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 backtrader as bt

class SmaCrossStrategy(bt.Strategy):
    def __init__(self):
        self.sma = bt.indicators.SimpleMovingAverage(self.datas[0], period=20)

    def next(self):
        if self.data.close[0] > self.sma[0]:
            self.buy()
        elif self.data.close[0] < self.sma[0]:
            self.sell()

cerebro = bt.Cerebro()
data = bt.feeds.YahooFinanceData(dataname='AAPL', fromdate=datetime(2020,1,1), todate=datetime(2021,1,1))
cerebro.adddata(data)
cerebro.addstrategy(SmaCrossStrategy)
cerebro.run()
cerebro.plot()

# 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()

pip install python-binance

from binance.client import Client
from binance.enums import *

# Khởi tạo client
api_key = 'YOUR_API_KEY'
api_secret = 'YOUR_API_SECRET'
client = Client(api_key, api_secret)

# Kiểm tra kết nối
print(client.get_system_status())

# Lấy giá hiện tại của BTC/USDT
btc_price = client.get_symbol_ticker(symbol="BTCUSDT")
print(f"Giá BTC/USDT: {btc_price['price']}")

# Lấy dữ liệu kline/candlestick
klines = client.get_klines(
    symbol='BTCUSDT',
    interval=Client.KLINE_INTERVAL_1HOUR,
    limit=100
)

# Chuyển đổi dữ liệu thành DataFrame
import pandas as pd
df = pd.DataFrame(klines, columns=[
    'timestamp', 'open', 'high', 'low', 'close', 'volume',
    'close_time', 'quote_asset_volume', 'number_of_trades',
    'taker_buy_base_asset_volume', 'taker_buy_quote_asset_volume', 'ignore'
])

from binance.websockets import BinanceSocketManager
from binance.client import Client

def process_message(msg):
    print(f"Giá mới: {msg['p']}")

# Khởi tạo WebSocket
bm = BinanceSocketManager(client)
conn_key = bm.start_symbol_ticker_socket('BTCUSDT', process_message)
bm.start()

# Lấy order book
depth = client.get_order_book(symbol='BTCUSDT', limit=5)
print("Bids (Lệnh mua):")
for bid in depth['bids']:
    print(f"Giá: {bid[0]}, Số lượng: {bid[1]}")
print("\nAsks (Lệnh bán):")
for ask in depth['asks']:
    print(f"Giá: {ask[0]}, Số lượng: {ask[1]}")

# Đặt lệnh mua thị trường
order = client.create_order(
    symbol='BTCUSDT',
    side=SIDE_BUY,
    type=ORDER_TYPE_MARKET,
    quantity=0.001
)

# Đặt lệnh mua giới hạn
order = client.create_order(
    symbol='BTCUSDT',
    side=SIDE_BUY,
    type=ORDER_TYPE_LIMIT,
    timeInForce=TIME_IN_FORCE_GTC,
    quantity=0.001,
    price='30000'
)

# Lấy thông tin tài khoản
account = client.get_account()
for balance in account['balances']:
    if float(balance['free']) > 0 or float(balance['locked']) > 0:
        print(f"Asset: {balance['asset']}")
        print(f"Free: {balance['free']}")
        print(f"Locked: {balance['locked']}")

# Lấy lịch sử giao dịch
trades = client.get_my_trades(symbol='BTCUSDT')
for trade in trades:
    print(f"Time: {trade['time']}")
    print(f"Price: {trade['price']}")
    print(f"Quantity: {trade['qty']}")
    print(f"Side: {trade['isBuyer']}")

from binance.exceptions import BinanceAPIException

try:
    # Thực hiện request
    client.get_account()
except BinanceAPIException as e:
    print(f"Lỗi API: {e.status_code} - {e.message}")

# Kiểm tra rate limits
rate_limits = client.get_exchange_info()
for limit in rate_limits['rateLimits']:
    print(f"Limit Type: {limit['rateLimitType']}")
    print(f"Interval: {limit['interval']}")
    print(f"Limit: {limit['limit']}")

from binance.client import Client
from binance.enums import *
import time

def trading_bot():
    # Khởi tạo client
    client = Client(api_key, api_secret)
    
    while True:
        try:
            # Lấy giá hiện tại
            ticker = client.get_symbol_ticker(symbol="BTCUSDT")
            current_price = float(ticker['price'])
            
            # Lấy dữ liệu kline
            klines = client.get_klines(
                symbol='BTCUSDT',
                interval=Client.KLINE_INTERVAL_1HOUR,
                limit=100
            )
            
            # Tính toán chỉ báo (ví dụ: SMA)
            closes = [float(k[4]) for k in klines]
            sma20 = sum(closes[-20:]) / 20
            
            # Logic giao dịch đơn giản
            if current_price > sma20:
                # Đặt lệnh mua
                order = client.create_order(
                    symbol='BTCUSDT',
                    side=SIDE_BUY,
                    type=ORDER_TYPE_MARKET,
                    quantity=0.001
                )
            elif current_price < sma20:
                # Đặt lệnh bán
                order = client.create_order(
                    symbol='BTCUSDT',
                    side=SIDE_SELL,
                    type=ORDER_TYPE_MARKET,
                    quantity=0.001
                )
            
            # Đợi 1 phút
            time.sleep(60)
            
        except Exception as e:
            print(f"Lỗi: {e}")
            time.sleep(60)

if __name__ == "__main__":
    trading_bot()

pip install pandas numpy matplotlib yfinance ta-lib

import yfinance as yf
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt

# Lấy dữ liệu giá cổ phiếu
symbol = "AAPL"  # Apple Inc.
start_date = "2023-01-01"
end_date = "2024-01-01"

df = yf.download(symbol, start=start_date, end=end_date)

def calculate_ma(data, window):
    return data.rolling(window=window).mean()

# Tính toán MA 20 và MA 50
df['MA20'] = calculate_ma(df['Close'], 20)
df['MA50'] = calculate_ma(df['Close'], 50)

def calculate_rsi(data, window=14):
    delta = data.diff()
    gain = (delta.where(delta > 0, 0)).rolling(window=window).mean()
    loss = (-delta.where(delta < 0, 0)).rolling(window=window).mean()
    rs = gain / loss
    return 100 - (100 / (1 + rs))

# Tính toán RSI
df['RSI'] = calculate_rsi(df['Close'])

def calculate_macd(data, fast=12, slow=26, signal=9):
    exp1 = data.ewm(span=fast, adjust=False).mean()
    exp2 = data.ewm(span=slow, adjust=False).mean()
    macd = exp1 - exp2
    signal_line = macd.ewm(span=signal, adjust=False).mean()
    return macd, signal_line

# Tính toán MACD
df['MACD'], df['Signal'] = calculate_macd(df['Close'])

def ma_crossover_strategy(df):
    df['Signal'] = 0
    df.loc[df['MA20'] > df['MA50'], 'Signal'] = 1  # Tín hiệu mua
    df.loc[df['MA20'] < df['MA50'], 'Signal'] = -1  # Tín hiệu bán
    return df

# Áp dụng chiến lược
df = ma_crossover_strategy(df)

def rsi_strategy(df, overbought=70, oversold=30):
    df['RSI_Signal'] = 0
    df.loc[df['RSI'] < oversold, 'RSI_Signal'] = 1  # Tín hiệu mua
    df.loc[df['RSI'] > overbought, 'RSI_Signal'] = -1  # Tín hiệu bán
    return df

# Áp dụng chiến lược
df = rsi_strategy(df)

def plot_technical_analysis(df):
    # Tạo subplot
    fig, (ax1, ax2, ax3) = plt.subplots(3, 1, figsize=(15, 12), gridspec_kw={'height_ratios': [3, 1, 1]})
    
    # Plot giá và MA
    ax1.plot(df.index, df['Close'], label='Giá đóng cửa')
    ax1.plot(df.index, df['MA20'], label='MA20')
    ax1.plot(df.index, df['MA50'], label='MA50')
    ax1.set_title('Giá và Moving Average')
    ax1.legend()
    
    # Plot RSI
    ax2.plot(df.index, df['RSI'], label='RSI')
    ax2.axhline(y=70, color='r', linestyle='--')
    ax2.axhline(y=30, color='g', linestyle='--')
    ax2.set_title('RSI')
    ax2.legend()
    
    # Plot MACD
    ax3.plot(df.index, df['MACD'], label='MACD')
    ax3.plot(df.index, df['Signal'], label='Signal')
    ax3.set_title('MACD')
    ax3.legend()
    
    plt.tight_layout()
    plt.show()