One post tagged with "tiền điện tử"

import numpy as np
import pandas as pd
from binance.client import Client

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

# Lấy dữ liệu
klines = client.get_historical_klines("BTCUSDT", Client.KLINE_INTERVAL_1DAY, "1 year ago UTC")

# Chuyển đổi sang DataFrame
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'])

# Xử lý dữ liệu
df['timestamp'] = pd.to_datetime(df['timestamp'], unit='ms')
df['close'] = pd.to_numeric(df['close'])
df.set_index('timestamp', inplace=True)

# Tính toán trung bình động
df['MA20'] = df['close'].rolling(window=20).mean()
df['MA50'] = df['close'].rolling(window=50).mean()

# Tạo tín hiệu giao dịch
df['signal'] = 0
df['signal'] = np.where(df['MA20'] > df['MA50'], 1, 0)
df['position'] = df['signal'].diff()

# Hiển thị các điểm mua và bán
buy_signals = df[df['position'] == 1]
sell_signals = df[df['position'] == -1]

print("Điểm mua:")
print(buy_signals[['close', 'MA20', 'MA50']])
print("\nĐiểm bán:")
print(sell_signals[['close', 'MA20', 'MA50']])

import pandas as pd
import numpy as np
from binance.client import Client
import talib

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

# Lấy dữ liệu
klines = client.get_historical_klines("BTCUSDT", Client.KLINE_INTERVAL_4HOUR, "3 months ago UTC")

# Chuyển đổi sang DataFrame
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'])

# Xử lý dữ liệu
df['timestamp'] = pd.to_datetime(df['timestamp'], unit='ms')
df['close'] = pd.to_numeric(df['close'])
df.set_index('timestamp', inplace=True)

# Tính toán RSI
df['RSI'] = talib.RSI(df['close'].values, timeperiod=14)

# Tạo tín hiệu giao dịch
df['signal'] = 0
df['signal'] = np.where(df['RSI'] < 30, 1, 0)  # Mua khi RSI < 30
df['signal'] = np.where(df['RSI'] > 70, -1, df['signal'])  # Bán khi RSI > 70

# Lọc tín hiệu để tránh nhiều tín hiệu liên tiếp
df['position'] = df['signal'].diff().fillna(0)

# Hiển thị kết quả
buy_signals = df[df['position'] == 1]
sell_signals = df[df['position'] == -1]

print("Tín hiệu mua (RSI quá bán):")
print(buy_signals[['close', 'RSI']])
print("\nTín hiệu bán (RSI quá mua):")
print(sell_signals[['close', 'RSI']])

import numpy as np
import pandas as pd
from binance.client import Client
from binance.enums import *

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

# Cấu hình grid trading
symbol = "BTCUSDT"
lower_price = 40000  # Giá dưới của grid
upper_price = 50000  # Giá trên của grid
grid_number = 10     # Số lượng grid
investment = 10000   # Tổng số tiền đầu tư (USDT)

# Tính toán khoảng cách giữa các grid
grid_size = (upper_price - lower_price) / grid_number
grid_investment = investment / grid_number

# Tạo các grid
grids = []
for i in range(grid_number + 1):
    price = lower_price + i * grid_size
    grids.append({
        "price": price,
        "buy_order": None,
        "sell_order": None
    })

# Hàm mô phỏng tạo lệnh mua
def place_buy_order(symbol, price, quantity):
    # Trong thực tế, bạn sẽ sử dụng client.create_order() để tạo lệnh thực tế
    print(f"Đặt lệnh MUA {quantity:.5f} {symbol} tại giá {price:.2f}")
    return {"symbol": symbol, "side": "BUY", "price": price, "quantity": quantity}

# Hàm mô phỏng tạo lệnh bán
def place_sell_order(symbol, price, quantity):
    # Trong thực tế, bạn sẽ sử dụng client.create_order() để tạo lệnh thực tế
    print(f"Đặt lệnh BÁN {quantity:.5f} {symbol} tại giá {price:.2f}")
    return {"symbol": symbol, "side": "SELL", "price": price, "quantity": quantity}

# Thiết lập grid bằng cách đặt các lệnh mua tại các mức giá
for i in range(grid_number):
    price = grids[i]["price"]
    quantity = grid_investment / price
    grids[i]["buy_order"] = place_buy_order(symbol, price, quantity)
    
    # Nếu lệnh mua được khớp, đặt lệnh bán ở mức giá cao hơn
    if i < grid_number:
        sell_price = grids[i+1]["price"]
        grids[i]["sell_order"] = place_sell_order(symbol, sell_price, quantity)

print("\nThiết lập Grid Trading hoàn tất!")
print(f"Phạm vi giao dịch: {lower_price:.2f} - {upper_price:.2f} USDT")
print(f"Kích thước grid: {grid_size:.2f} USDT")
print(f"Đầu tư mỗi grid: {grid_investment:.2f} USDT")

import time
import pandas as pd
from binance.client import Client
from datetime import datetime, timedelta

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

# Cấu hình DCA
symbol = "BTCUSDT"
investment_amount = 100  # USD mỗi lần đầu tư
interval_days = 7        # Đầu tư mỗi 7 ngày
total_periods = 10       # Tổng số lần đầu tư

# Lấy thông tin giá hiện tại
def get_current_price(symbol):
    ticker = client.get_symbol_ticker(symbol=symbol)
    return float(ticker['price'])

# Mô phỏng chiến lược DCA
def simulate_dca():
    total_investment = 0
    total_coins = 0
    dca_results = []
    
    # Ngày bắt đầu (giả định từ 70 ngày trước)
    start_date = datetime.now() - timedelta(days=70)
    
    for i in range(total_periods):
        # Ngày đầu tư
        investment_date = start_date + timedelta(days=i * interval_days)
        
        # Lấy dữ liệu giá từ ngày đầu tư
        klines = client.get_historical_klines(
            symbol, 
            Client.KLINE_INTERVAL_1DAY,
            investment_date.strftime("%d %b, %Y 00:00:00"),
            (investment_date + timedelta(days=1)).strftime("%d %b, %Y 00:00:00")
        )
        
        if not klines:
            print(f"Không có dữ liệu cho ngày {investment_date.strftime('%Y-%m-%d')}")
            continue
            
        # Lấy giá đóng cửa
        price = float(klines[0][4])
        
        # Tính lượng tiền điện tử mua được
        coins_bought = investment_amount / price
        
        # Cập nhật tổng
        total_investment += investment_amount
        total_coins += coins_bought
        
        # Ghi nhận kết quả
        dca_results.append({
            "date": investment_date.strftime("%Y-%m-%d"),
            "price": price,
            "investment": investment_amount,
            "coins_bought": coins_bought,
            "total_investment": total_investment,
            "total_coins": total_coins,
            "current_value": total_coins * price,
            "roi": (total_coins * price / total_investment - 1) * 100
        })
    
    # Chuyển kết quả thành DataFrame
    return pd.DataFrame(dca_results)

# Thực hiện mô phỏng
results = simulate_dca()
print(results[["date", "price", "coins_bought", "total_coins", "roi"]])

# Tính toán ROI cuối cùng
current_price = get_current_price(symbol)
final_value = results.iloc[-1]["total_coins"] * current_price
final_roi = (final_value / results.iloc[-1]["total_investment"] - 1) * 100

print(f"\nKết quả cuối cùng tại giá hiện tại ({current_price:.2f} USD):")
print(f"Tổng đầu tư: {results.iloc[-1]['total_investment']:.2f} USD")
print(f"Tổng số coin: {results.iloc[-1]['total_coins']:.8f}")
print(f"Giá trị hiện tại: {final_value:.2f} USD")
print(f"ROI: {final_roi:.2f}%")

import pandas as pd
import numpy as np
from binance.client import Client
from datetime import datetime, timedelta

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

# Cấu hình danh mục đầu tư
portfolio = {
    "BTC": 0.5,  # 50% Bitcoin
    "ETH": 0.3,  # 30% Ethereum
    "BNB": 0.2   # 20% Binance Coin
}

initial_investment = 10000  # USD
rebalance_frequency = 30    # Rebalance mỗi 30 ngày

# Lấy giá hiện tại
def get_current_prices(symbols):
    prices = {}
    for symbol in symbols:
        ticker = client.get_symbol_ticker(symbol=symbol+"USDT")
        prices[symbol] = float(ticker['price'])
    return prices

# Mô phỏng chiến lược rebalancing
def simulate_rebalancing():
    # Giả định bắt đầu từ 180 ngày trước
    start_date = datetime.now() - timedelta(days=180)
    current_date = start_date
    end_date = datetime.now()
    
    # Dữ liệu ban đầu
    current_prices = {}
    for symbol in portfolio:
        klines = client.get_historical_klines(
            symbol+"USDT", 
            Client.KLINE_INTERVAL_1DAY,
            start_date.strftime("%d %b, %Y 00:00:00"),
            (start_date + timedelta(days=1)).strftime("%d %b, %Y 00:00:00")
        )
        if klines:
            current_prices[symbol] = float(klines[0][4])
    
    # Tính toán số lượng coin ban đầu
    holdings = {}
    for symbol, allocation in portfolio.items():
        investment_amount = initial_investment * allocation
        holdings[symbol] = investment_amount / current_prices[symbol]
    
    rebalance_results = []
    
    # Ghi nhận trạng thái ban đầu
    initial_holdings_value = sum(holdings[s] * current_prices[s] for s in portfolio)
    rebalance_results.append({
        "date": start_date.strftime("%Y-%m-%d"),
        "action": "Initial",
        "portfolio_value": initial_holdings_value,
        "holdings": holdings.copy(),
        "prices": current_prices.copy()
    })
    
    # Mô phỏng qua thời gian
    while current_date < end_date:
        current_date += timedelta(days=rebalance_frequency)
        
        # Lấy giá mới
        for symbol in portfolio:
            klines = client.get_historical_klines(
                symbol+"USDT", 
                Client.KLINE_INTERVAL_1DAY,
                current_date.strftime("%d %b, %Y 00:00:00"),
                (current_date + timedelta(days=1)).strftime("%d %b, %Y 00:00:00")
            )
            if klines:
                current_prices[symbol] = float(klines[0][4])
        
        # Tính giá trị danh mục hiện tại
        current_value = sum(holdings[s] * current_prices[s] for s in portfolio)
        
        # Tính toán cân bằng lại
        new_holdings = {}
        for symbol, target_allocation in portfolio.items():
            # Giá trị mục tiêu
            target_value = current_value * target_allocation
            # Số lượng coin mới
            new_holdings[symbol] = target_value / current_prices[symbol]
        
        # Ghi nhận kết quả rebalance
        rebalance_results.append({
            "date": current_date.strftime("%Y-%m-%d"),
            "action": "Rebalance",
            "portfolio_value": current_value,
            "holdings": new_holdings.copy(),
            "prices": current_prices.copy()
        })
        
        # Cập nhật holdings
        holdings = new_holdings
    
    # Chuyển kết quả thành DataFrame
    return pd.DataFrame(rebalance_results)

# Thực hiện mô phỏng
results = simulate_rebalancing()

# Hiển thị kết quả
for i, row in results.iterrows():
    print(f"\n--- {row['date']} ({row['action']}) ---")
    print(f"Giá trị danh mục: ${row['portfolio_value']:.2f}")
    
    for symbol in portfolio:
        coin_value = row['holdings'][symbol] * row['prices'][symbol]
        allocation = coin_value / row['portfolio_value'] * 100
        print(f"{symbol}: {row['holdings'][symbol]:.6f} (${coin_value:.2f}, {allocation:.2f}%)")

# Tính ROI
initial_value = results.iloc[0]["portfolio_value"]
final_value = results.iloc[-1]["portfolio_value"]
roi = (final_value / initial_value - 1) * 100

print(f"\nKết quả cuối cùng:")
print(f"Giá trị ban đầu: ${initial_value:.2f}")
print(f"Giá trị cuối cùng: ${final_value:.2f}")
print(f"ROI: {roi:.2f}%")