import requests
import time
import threading
# Contract trading API (example)
BINANCE_CONTRACT_API_URL = 'https://api.binance.com/api/v3/futures/price'
KUCOIN_CONTRACT_API_URL = 'https://api.kucoin.com/api/v1/contracts/market/price'
BINANCE_SYMBOL = 'BTCUSDT'
KUCOIN_SYMBOL = 'BTC-USDT'
# Set the threshold for price difference and minimum profit
PRICE_DIFF_THRESHOLD = 20 # Set the minimum price difference
MIN_PROFIT = 10 # Minimum arbitrage profit (in USD)
# Get real-time price of Binance contract
def get_binance_contract_price():
response = requests.get(f'{BINANCE_CONTRACT_API_URL}?symbol={BINANCE_SYMBOL}')
data = response.json()
return float(data['price']) # Get the latest price of BTC contract
# Get real-time price of KuCoin contract
def get_kucoin_contract_price():
response = requests.get(f'{KUCOIN_CONTRACT_API_URL}?symbol={KUCOIN_SYMBOL}')
data = response.json()
return float(data['data']['price']) # Get the latest price of BTC contract
# Simulate contract opening operation (long/short)
def execute_open_order(action, amount, exchange):
print(f"Executing {action} order of {amount} BTC on {exchange}")
# Here you can call the exchange's API for real opening operations (long or short)
# Simulate contract closing operation (sell and buy simultaneously)
def execute_close_order(action, amount, exchange):
print(f"Executing {action} order of {amount} BTC on {exchange}")
# Here you can call the exchange's API for real closing operations (sell or buy)
# Execute contract arbitrage operation (open and close positions simultaneously)
def perform_arbitrage(binance_price, kucoin_price):
# Assume we trade 0.1 BTC
amount_to_trade = 0.1
# Calculate profit
profit = (kucoin_price - binance_price) * amount_to_trade
if profit >= MIN_PROFIT:
print(f"Arbitrage opportunity found! Buy at {binance_price}, Sell at {kucoin_price}, Profit: {profit}")
# Opening position: Go long on Binance (buy) and short on KuCoin (sell)
def binance_open():
execute_open_order('BUY', amount_to_trade, 'Binance')
def kucoin_open():
execute_open_order('SELL', amount_to_trade, 'KuCoin')
# Start concurrent execution of opening operations
binance_thread = threading.Thread(target=binance_open)
kucoin_thread = threading.Thread(target=kucoin_open)
binance_thread.start()
kucoin_thread.start()
# Wait for both threads to complete opening positions
binance_thread.join()
kucoin_thread.join()
# Close positions simultaneously when the price difference is significant
if binance_price < kucoin_price - PRICE_DIFF_THRESHOLD:
def binance_close():
execute_close_order('SELL', amount_to_trade, 'Binance')
def kucoin_close():
execute_close_order('BUY', amount_to_trade, 'KuCoin')
# Start concurrent execution of closing operations
binance_close_thread = threading.Thread(target=binance_close)
kucoin_close_thread = threading.Thread(target=kucoin_close)
binance_close_thread.start()
kucoin_close_thread.start()
# Wait for the closing to complete
binance_close_thread.join()
kucoin_close_thread.join()
else:
print(f"Profit {profit} is less than minimum required.")
# Main program: Contract arbitrage detection
def arb_trade():
while True:
binance_price = get_binance_contract_price()
kucoin_price = get_kucoin_contract_price()
# Determine arbitrage conditions
if binance_price < kucoin_price - PRICE_DIFF_THRESHOLD:
perform_arbitrage(binance_price, kucoin_price)
else:
print("No arbitrage opportunity found.")
# Wait for a while before checking again
time.sleep(2)
# Start the contract arbitrage program
if __name__ == "__main__":
arb_trade()
