|
|
from binance import BinanceSpotHttp, OrderStatus, OrderType, OrderSide
|
|
|
from utils import config
|
|
|
from utils import round_to
|
|
|
from utils import utility
|
|
|
|
|
|
|
|
|
class BinanceTrader(object):
|
|
|
|
|
|
def __init__(self):
|
|
|
"""
|
|
|
:param api_key:
|
|
|
:param secret:
|
|
|
:param trade_type: 交易的类型， only support future and spot.
|
|
|
"""
|
|
|
self.loop_counts = 0
|
|
|
self.config_error_counts = 0 #止损价配置不当，提示次数
|
|
|
self.sleep_time = config.sleep_time #循环间隔秒数
|
|
|
self.cancel_time = config.cancel_time #取消订单周期
|
|
|
self.http_client = BinanceSpotHttp(api_key=config.api_key, secret=config.api_secret, proxy_host=config.proxy_host, proxy_port=config.proxy_port)
|
|
|
|
|
|
self.buy_orders = [] # 本地买单列表.
|
|
|
self.sell_orders = [] # 本地卖单列表.
|
|
|
self.deficit_scroll_map = {} # 滚动止盈的清仓价
|
|
|
|
|
|
|
|
|
def get_avg_price_5min(self):
|
|
|
#获取5分钟内的平均价
|
|
|
ticker = self.http_client.get_avg_price_5min(config.symbol)
|
|
|
price = 0
|
|
|
if ticker:
|
|
|
price = float(ticker.get('price', 0))
|
|
|
return price
|
|
|
|
|
|
def get_latest_price(self):
|
|
|
#获取最新价格
|
|
|
ticker = self.http_client.get_latest_price(config.symbol)
|
|
|
price = 0
|
|
|
if ticker:
|
|
|
price = float(ticker.get('price', 0))
|
|
|
return price
|
|
|
|
|
|
def get_price_change_percent_24h(self):
|
|
|
#获取24h内的价格变化百分比数据
|
|
|
ticker = self.http_client.get_price_info_24h(config.symbol)
|
|
|
priceChangePercent = 0
|
|
|
if ticker:
|
|
|
priceChangePercent = float(ticker.get('priceChangePercent', 0))
|
|
|
return priceChangePercent
|
|
|
|
|
|
def get_bid_ask_price(self):
|
|
|
#最高买价 最低卖价
|
|
|
ticker = self.http_client.get_ticker(config.symbol)
|
|
|
|
|
|
bid_price = 0
|
|
|
ask_price = 0
|
|
|
if ticker:
|
|
|
bid_price = float(ticker.get('bidPrice', 0))
|
|
|
ask_price = float(ticker.get('askPrice', 0))
|
|
|
|
|
|
return bid_price, ask_price
|
|
|
|
|
|
def get_depth(self,limit):
|
|
|
ticker = self.http_client.get_order_book(config.symbol,limit=limit)
|
|
|
if ticker:
|
|
|
#high_price = float(ticker[0][2])
|
|
|
print(ticker)
|
|
|
return 123
|
|
|
|
|
|
|
|
|
def get_kline(self,interval):
|
|
|
ticker = self.http_client.get_kline(config.symbol,interval=interval,limit=1)
|
|
|
if ticker:
|
|
|
high_price = float(ticker[0][2])
|
|
|
low_price = float(ticker[0][3])
|
|
|
return low_price, high_price
|
|
|
|
|
|
# 获取倒数第二个k线数据
|
|
|
def get_kline_pre4(self,interval):
|
|
|
ticker = self.http_client.get_kline(config.symbol,interval=interval,limit=4)
|
|
|
if ticker:
|
|
|
high_price = float(ticker[3][2])
|
|
|
low_price = float(ticker[3][3])
|
|
|
return low_price, high_price
|
|
|
|
|
|
def create_buy_order(self,quantity,buy_price):
|
|
|
new_buy_order = self.http_client.place_order(symbol=config.symbol, order_side=OrderSide.BUY,
|
|
|
order_type=OrderType.LIMIT, quantity=quantity,
|
|
|
price=buy_price)
|
|
|
if new_buy_order:
|
|
|
# 买单维护到买单列表待处理
|
|
|
self.buy_orders.append(new_buy_order)
|
|
|
print(f"买单创建 价格: {buy_price}, 数量: {quantity} ")
|
|
|
else:
|
|
|
print(f"买单创建失败 价格: {buy_price}, 数量: {quantity} ")
|
|
|
|
|
|
def create_sell_order(self,quantity,sell_price):
|
|
|
new_sell_order = self.http_client.place_order(symbol=config.symbol, order_side=OrderSide.SELL,
|
|
|
order_type=OrderType.LIMIT, quantity=quantity, price=sell_price)
|
|
|
if new_sell_order:
|
|
|
# 放到卖单列表待处理
|
|
|
self.sell_orders.append(new_sell_order)
|
|
|
print(f"卖单创建 价格: {sell_price}, 数量: {quantity} ")
|
|
|
else:
|
|
|
print(f"卖单创建失败 价格: {sell_price}, 数量: {quantity} ")
|
|
|
|
|
|
def create_sell_order_by_client_id(self,quantity,sell_price,client_order_id):
|
|
|
new_sell_order = self.http_client.place_order(symbol=config.symbol, order_side=OrderSide.SELL,
|
|
|
order_type=OrderType.LIMIT, quantity=quantity, price=sell_price,client_order_id=client_order_id)
|
|
|
if new_sell_order is not None:
|
|
|
# 放到卖单列表待处理
|
|
|
self.sell_orders.append(new_sell_order)
|
|
|
print(f"卖单创建 价格: {sell_price}, 数量: {quantity} ")
|
|
|
return True
|
|
|
else:
|
|
|
print(f"卖单创建失败 价格: {sell_price}, 数量: {quantity} ")
|
|
|
return False
|
|
|
|
|
|
def create_sell_order_market(self,quantity):
|
|
|
new_sell_order = self.http_client.place_order(symbol=config.symbol, order_side=OrderSide.SELL,
|
|
|
order_type=OrderType.MARKET, quantity=quantity)
|
|
|
if new_sell_order:
|
|
|
# 市价订单必定成功
|
|
|
self.sell_orders.append(new_sell_order)
|
|
|
print(f"交易对：{config.symbol} 市价卖出数量: {quantity} ")
|
|
|
return True
|
|
|
else:
|
|
|
print(f"交易对：{config.symbol} 卖单创建失败 市价卖出数量: {quantity} ")
|
|
|
return False
|
|
|
|
|
|
def cancel_single_order(self,cancel_order):
|
|
|
order = self.http_client.cancel_order(config.symbol,cancel_order.get('clientOrderId'))
|
|
|
if order is None:
|
|
|
utility.alert(f"订单撤销失败 symbol: {config.symbol}, clientOrderId: {cancel_order.get('clientOrderId')} ")
|
|
|
return False
|
|
|
else:
|
|
|
print(f"订单撤销成功 symbol: {config.symbol}, clientOrderId: {cancel_order.get('clientOrderId')} ")
|
|
|
return True
|
|
|
|
|
|
|
|
|
def cancel_open_orders(self):
|
|
|
open_orders_list = self.http_client.get_open_orders(config.symbol)
|
|
|
for open_order in open_orders_list:
|
|
|
if open_order.get('status') == OrderStatus.NEW.value and open_order.get('side') == OrderSide.BUY.value:
|
|
|
#只取消本客户端创建的买单
|
|
|
if open_order.get('clientOrderId') and config.symbol in open_order.get('clientOrderId'):
|
|
|
self.cancel_single_order(open_order)
|
|
|
print(f"买单{open_order.get('clientOrderId')}已取消取消")
|
|
|
|
|
|
def sync_open_orders(self):
|
|
|
open_orders_list = self.http_client.get_open_orders(config.symbol)
|
|
|
for open_order in open_orders_list:
|
|
|
#只同步本客户端创建的订单
|
|
|
if open_order.get('clientOrderId') and config.symbol in open_order.get('clientOrderId'):
|
|
|
if open_order.get('status') == OrderStatus.NEW.value and open_order.get('side') == OrderSide.BUY.value:
|
|
|
self.buy_orders.append(open_order)
|
|
|
print(f"买单{open_order.get('clientOrderId')}同步到本地")
|
|
|
if open_order.get('status') == OrderStatus.NEW.value and open_order.get('side') == OrderSide.SELL.value:
|
|
|
self.sell_orders.append(open_order)
|
|
|
print(f"卖单{open_order.get('clientOrderId')}同步到本地")
|
|
|
|
|
|
#网格交易核心逻辑.
|
|
|
def grid_trader(self):
|
|
|
"""
|
|
|
#网格交易核心逻辑.
|
|
|
"""
|
|
|
|
|
|
quantity = round_to(float(config.quantity), float(config.min_qty)) ## quantity是config.quantity到config.min_qty的精度转换
|
|
|
profit_scroll = float(config.profit_scroll) ## 每次刷新止盈价的比例
|
|
|
deficit_scroll = float(config.deficit_scroll) ## 每次刷新止损价的比例
|
|
|
profit_intend = float(config.profit_intend) ## 每次准备刷新止盈价的比例，到了这个比例直接刷
|
|
|
gap_percent= float(config.gap_percent) ## 卖单提价比例
|
|
|
|
|
|
self.loop_counts+=1
|
|
|
print(f"{utility.cn_time()} 第{self.loop_counts}轮循环开始")
|
|
|
|
|
|
bid_price, ask_price = self.get_bid_ask_price()
|
|
|
print(f"{config.symbol}:最高买价bid_price: {bid_price}, 最低卖价ask_price: {ask_price}")
|
|
|
avg_price_5min = float(self.get_avg_price_5min())
|
|
|
#latest_price = self.get_latest_price()
|
|
|
|
|
|
#5分钟k线 15分钟k线
|
|
|
low_price_in_15m, high_price_in_15m = self.get_kline("15m")
|
|
|
print(f"{config.symbol}:15分钟最低价: {low_price_in_15m}, 15分钟最高价: {high_price_in_15m}")
|
|
|
|
|
|
low_price_in_4h, high_price_in_4h = self.get_kline("4h")
|
|
|
low_price_pre_in_4h, high_price_pre_in_4h = self.get_kline_pre4("2h")
|
|
|
print(f"low_price_in_4h: {low_price_in_4h}")
|
|
|
print(f"high_price_in_4h: {high_price_in_4h}")
|
|
|
print(f"low_price_pre_in_4h: {low_price_pre_in_4h}")
|
|
|
print(f"high_price_pre_in_4h: {high_price_pre_in_4h}")
|
|
|
# 取波峰波谷的中间值
|
|
|
peak_price = high_price_in_4h if high_price_in_4h <= high_price_pre_in_4h else high_price_pre_in_4h
|
|
|
bottom_price = low_price_in_4h if low_price_in_4h >= low_price_pre_in_4h else low_price_pre_in_4h
|
|
|
delta_price_in_4h = float(peak_price)-float(bottom_price)
|
|
|
price_stop_to_sell = float(bottom_price) + delta_price_in_4h * 0.1
|
|
|
price_stop_to_buy = float(peak_price) - delta_price_in_4h * 0.8
|
|
|
print(f"high_price_in_4h_4h: {peak_price}")
|
|
|
print(f"low_price_in_4h_4h: {bottom_price}")
|
|
|
print(f"价格上限： {price_stop_to_buy}")
|
|
|
print(f"价格下限： {price_stop_to_sell}")
|
|
|
# price_stop_to_sell = float(config.price_stop_to_sell)
|
|
|
# price_stop_to_buy = float(config.price_stop_to_buy)
|
|
|
|
|
|
|
|
|
|
|
|
self.buy_orders.sort(key=lambda x: float(x['price']), reverse=True) # 最高价到最低价.
|
|
|
self.sell_orders.sort(key=lambda x: float(x['price']), reverse=True) # 最高价到最低价.
|
|
|
|
|
|
|
|
|
buy_delete_orders = [] # 需要删除的买单
|
|
|
sell_delete_orders = [] # 需要删除的卖单
|
|
|
|
|
|
|
|
|
|
|
|
# 买单逻辑,检查买单列表成交的情况.一旦成功立即加价卖
|
|
|
print("-------------买单逻辑-----------------")
|
|
|
for buy_order in self.buy_orders:
|
|
|
check_order = self.http_client.get_order(buy_order.get('symbol', config.symbol),client_order_id=buy_order.get('clientOrderId'))
|
|
|
if check_order:
|
|
|
order_status = check_order.get('status')
|
|
|
order_price = check_order.get('price')
|
|
|
order_orig_qty = check_order.get('origQty')
|
|
|
order_client_id = buy_order.get('clientOrderId')
|
|
|
|
|
|
#取消状态的买单 不管
|
|
|
if order_status == OrderStatus.CANCELED.value:
|
|
|
buy_delete_orders.append(buy_order)
|
|
|
print(f"买单{order_client_id}状态为取消: {order_status}")
|
|
|
|
|
|
#成交状态买单，需要处理
|
|
|
elif order_status == OrderStatus.FILLED.value:
|
|
|
print(f"成交状态的买单： {order_client_id} 成交时间: {utility.cn_time()} 价格: {order_price} 数量: {order_orig_qty}")
|
|
|
# 买单成交后，提高价格，挂盈利卖单
|
|
|
sell_price = round_to(float(order_price) * (1 + float(config.gap_percent)), float(config.min_price))
|
|
|
if 0 < sell_price < ask_price:
|
|
|
# 防止价格小于最低卖价ask_price
|
|
|
sell_price = round_to(ask_price, float(config.min_price))
|
|
|
#如果卖价小于设定的持仓价格price_stop_to_sell，将卖价提高至持仓价，才交易
|
|
|
if 0 < sell_price < price_stop_to_sell:
|
|
|
print(f"卖价{sell_price} 小于持仓价{price_stop_to_sell} ，已调整为持仓价交易")
|
|
|
sell_price = price_stop_to_sell
|
|
|
#盈利卖单挂
|
|
|
if self.create_sell_order(quantity, sell_price):
|
|
|
print(f"{utility.cn_time()} :交易对：{config.symbol}, 买单 {order_client_id} 成交, 价格: {order_price}, 数量: {order_orig_qty}")
|
|
|
# 盈利卖单挂成功的话，删掉本买单
|
|
|
buy_delete_orders.append(buy_order)
|
|
|
if buy_order in self.buy_orders:
|
|
|
self.buy_orders.remove(buy_order)
|
|
|
|
|
|
|
|
|
|
|
|
#未成交的买单不处理
|
|
|
elif order_status == OrderStatus.NEW.value:
|
|
|
print(f"未成交的买单{order_client_id} 价格: {order_price}, 数量: {order_orig_qty}")
|
|
|
|
|
|
# 部分成交的买单 提示下就行了
|
|
|
elif order_status == OrderStatus.PARTIALLY_FILLED.value:
|
|
|
print(f"部分成交的买单{order_client_id} 价格: {order_price}, 数量: {order_orig_qty}")
|
|
|
|
|
|
#异常状态买单
|
|
|
else:
|
|
|
utility.alert(f"交易对：{config.symbol}, 时间: {utility.cn_time()}, 买单{order_client_id}失败{order_status}")
|
|
|
|
|
|
# 过期或者拒绝的订单删除掉.
|
|
|
for delete_order in buy_delete_orders:
|
|
|
if delete_order in self.buy_orders:
|
|
|
self.buy_orders.remove(delete_order)
|
|
|
|
|
|
|
|
|
# 卖单逻辑, 检查卖单成交情况
|
|
|
print("--------------卖单逻辑----------------")
|
|
|
for sell_order in self.sell_orders:
|
|
|
check_order = self.http_client.get_order(sell_order.get('symbol', config.symbol),client_order_id=sell_order.get('clientOrderId'))
|
|
|
if check_order:
|
|
|
order_status = check_order.get('status')
|
|
|
order_price = check_order.get('price')
|
|
|
order_orig_qty = check_order.get('origQty')
|
|
|
order_client_id = sell_order.get('clientOrderId')
|
|
|
#卖单状态为取消 不管
|
|
|
if order_status == OrderStatus.CANCELED.value:
|
|
|
sell_delete_orders.append(sell_order)
|
|
|
print(f"卖单{order_client_id}状态为取消: {order_status}")
|
|
|
|
|
|
#卖单状态为成交
|
|
|
elif order_status == OrderStatus.FILLED.value:
|
|
|
print(f"卖单{order_client_id}成交时间: {utility.cn_time()}, 价格: {order_price}, 数量: {order_orig_qty}")
|
|
|
#第一遍才发通知
|
|
|
if sell_order not in sell_delete_orders:
|
|
|
utility.alert(f"卖单成交: {utility.cn_time()} {order_client_id}, 交易对：{config.symbol}, 价格: {order_price}, 数量: {order_orig_qty}")
|
|
|
# 卖单成交，不再维护该卖单状态
|
|
|
sell_delete_orders.append(sell_order)
|
|
|
if sell_order in self.sell_orders:
|
|
|
self.sell_orders.remove(sell_order)
|
|
|
|
|
|
|
|
|
# 新挂的卖单 创建移动止盈策略
|
|
|
elif order_status == OrderStatus.NEW.value:
|
|
|
print(f"还没成交的卖单:{order_client_id} 价格: {order_price}, 数量: {order_orig_qty}")
|
|
|
print(f"当前最低卖价: {ask_price}")
|
|
|
orig_buy_price = float(order_price) / (float(gap_percent) + 1)
|
|
|
print(f"预估本单的买入价格: {orig_buy_price}")
|
|
|
triger_price = float(order_price) * float(profit_intend)
|
|
|
print(f"移动止盈触发价格: {triger_price}")
|
|
|
if ask_price >= triger_price:
|
|
|
print("最低卖价大于移动止盈触发价格，先删除本卖单，再创建一个更高价的卖单")
|
|
|
if self.cancel_single_order(check_order):
|
|
|
# 删除成功 再创建一个更高价的卖单
|
|
|
new_order_price_profit = float(order_price) * float(profit_scroll)
|
|
|
new_order_price_deficit = float(ask_price) * float(deficit_scroll)
|
|
|
new_order_price_profit = round_to(new_order_price_profit, float(config.min_price))
|
|
|
new_order_price_deficit = round_to(new_order_price_deficit, float(config.min_price))
|
|
|
print(f"new_order_price_profit: {new_order_price_profit}")
|
|
|
print(f"new_order_price_deficit: {new_order_price_deficit}")
|
|
|
profit_client_order_id = self.http_client.get_client_order_id()
|
|
|
profit_sell_order = self.create_sell_order_by_client_id(order_orig_qty,
|
|
|
new_order_price_profit,
|
|
|
profit_client_order_id)
|
|
|
if profit_sell_order:
|
|
|
print("----------------移动止盈触发成功-------yyyyyyyyyyyyyyyyyyyyyyyyyyyy------")
|
|
|
print(
|
|
|
f"{utility.cn_time()} :卖单 {order_client_id}滚动止盈触发新卖单{profit_client_order_id}，交易对：{config.symbol},新期望价格: {new_order_price_profit}, 数量: {order_orig_qty}")
|
|
|
# 移动止盈卖单挂成功的话，本地不再维护原卖单
|
|
|
sell_delete_orders.append(sell_order)
|
|
|
if sell_order in self.sell_orders:
|
|
|
self.sell_orders.remove(sell_order)
|
|
|
# 本地记录新卖单的止损价格
|
|
|
self.deficit_scroll_map[profit_client_order_id] = new_order_price_deficit
|
|
|
else:
|
|
|
print("----------------移动止盈触发失败------eeeeeeeeeeeeeeeeeeeeeeeeeeee-------")
|
|
|
print(
|
|
|
f"{utility.cn_time()} 移动止盈卖单创建失败 交易对：{config.symbol} 价格: {new_order_price_profit}, 数量: {order_orig_qty} ")
|
|
|
utility.alert(
|
|
|
f"{utility.cn_time()} 移动止盈卖单创建失败 交易对：{config.symbol} 价格: {new_order_price_profit}, 数量: {order_orig_qty} ")
|
|
|
else:
|
|
|
print("原买单删除失败")
|
|
|
|
|
|
# 当前卖单存在止损价，且最低卖价不大于止损价时候，止损处理掉当前卖单
|
|
|
# 其实所存的止损价是经过滚动止盈产生的，所以还是在盈利
|
|
|
# 当前卖价要大于买单价格才可以
|
|
|
elif order_client_id in self.deficit_scroll_map and ask_price <= self.deficit_scroll_map[order_client_id] and ask_price > orig_buy_price:
|
|
|
# 先删除本卖单，挂太高了，卖不出去
|
|
|
if self.cancel_open_orders(check_order):
|
|
|
# 市价卖出本订单待卖的币
|
|
|
self.create_sell_order_market(order_orig_qty)
|
|
|
print("----------移动止损成功--------------")
|
|
|
else:
|
|
|
print(f"止损卖单取消失败:{order_client_id} 价格: {order_price}, 数量: {order_orig_qty}")
|
|
|
|
|
|
|
|
|
|
|
|
# 部分成交的卖单 提示下就行了
|
|
|
elif order_status == OrderStatus.PARTIALLY_FILLED.value:
|
|
|
print(f"部分成交的卖单{order_client_id} 价格: {order_price}, 数量: {order_orig_qty}")
|
|
|
|
|
|
else:
|
|
|
utility.alert(f"挂卖单失败 交易对：{config.symbol}, 时间: {utility.cn_time()}, {order_status}")
|
|
|
|
|
|
#处理过期或者拒绝的订单，不在维护到本地
|
|
|
for delete_order in sell_delete_orders:
|
|
|
if delete_order in self.sell_orders:
|
|
|
self.sell_orders.remove(delete_order)
|
|
|
|
|
|
# 买单数量未满 并且卖单也没满时候 usdt没有积压 可以新建买单
|
|
|
if len(self.buy_orders) < int(config.max_orders) and len(self.sell_orders) < int(config.max_sell_orders):
|
|
|
print("买单数量未满，卖单也没积压，开始创建一个新买单：")
|
|
|
print("------------------------------")
|
|
|
if bid_price > 0:
|
|
|
buy_price = round_to(bid_price * (1 - float(config.gap_percent)), float(config.min_price))
|
|
|
##如果买价大于设定的抛仓价格price_stop_to_buy，将买价降低至抛仓价，才交易
|
|
|
if buy_price > price_stop_to_buy > 0:
|
|
|
buy_price = price_stop_to_buy
|
|
|
#动态价格保护，如果买价不高于15分钟k线最高值，说明价格在跌，适合买
|
|
|
if buy_price <= high_price_in_15m :
|
|
|
# 如果价格不大于5分钟内的平均价 说明价格还可以，能继续买入
|
|
|
if buy_price <= avg_price_5min:
|
|
|
buy_price = round_to(buy_price,float(config.min_price))
|
|
|
print(f"开始创建买单：价格{buy_price} 数量 {quantity} ")
|
|
|
self.create_buy_order(quantity,buy_price)
|
|
|
else:
|
|
|
print(f"买价 {buy_price}大于平均价 {avg_price_5min} 再等等")
|
|
|
else:
|
|
|
print(f"买价 {buy_price}大于15分钟最高价 {high_price_in_15m} 高位勿买")
|
|
|
|
|
|
# 买单数量过多，cancel_time 取消一次价格最离谱的买单
|
|
|
elif len(self.buy_orders) >= int(config.max_orders):
|
|
|
# cancel_time更新一次 主循环cancel_time/gcd_time次
|
|
|
cancel_period=self.cancel_time/self.sleep_time
|
|
|
print(f"当前买单数量达到{config.max_orders}，将在{(cancel_period - self.loop_counts % cancel_period)*self.sleep_time}秒后删除一个价格最离谱的买单")
|
|
|
if self.loop_counts % cancel_period == 0:
|
|
|
print(f"开始删除价格最离谱的买单：")
|
|
|
print("------------------------------")
|
|
|
# 最离谱到最接近
|
|
|
self.buy_orders.sort(key=lambda x: abs(float(x['price'])-float(avg_price_5min)), reverse=True)
|
|
|
impossible_order=self.buy_orders[0]
|
|
|
if self.cancel_single_order(impossible_order):
|
|
|
if impossible_order in self.buy_orders:
|
|
|
self.buy_orders.remove(impossible_order)
|
|
|
buy_delete_orders.append(impossible_order)
|
|
|
print(f"买单列表已满 价格离谱的买单{impossible_order.get('clientOrderId')}删除 价格: {impossible_order.get('price')}, 数量: {impossible_order.get('origQty')} ")
|
|
|
else:
|
|
|
print(f"买单列表已满 价格离谱的买单{impossible_order.get('clientOrderId')}删除失败 价格: {impossible_order.get('price')}, 数量: {impossible_order.get('origQty')} ")
|
|
|
for fade_order in self.buy_orders:
|
|
|
if float(fade_order.get('price')) > high_price_in_15m or float(fade_order.get('price')) < low_price_in_15m:
|
|
|
if fade_order in self.buy_orders:
|
|
|
self.buy_orders.remove(fade_order)
|
|
|
buy_delete_orders.append(fade_order)
|
|
|
print(f"取消价格未在15m k线的买单{fade_order.get('clientOrderId')} 价格: {impossible_order.get('price')}, 数量: {impossible_order.get('origQty')} ")
|
|
|
|
|
|
|
|
|
|
|
|
# 没有卖单的时候 暂时先不创建卖单，防止利润计算错误
|
|
|
if len(self.sell_orders) <= 0:
|
|
|
print(f"当前没有卖单，请注意查看{config.symbol}余额")
|
|
|
print("------------------------------")
|
|
|
|
|
|
|
|
|
|
|
|
#卖单过多，暂不处理
|
|
|
elif len(self.sell_orders) > int(config.max_orders):
|
|
|
print("卖单过多：")
|
|
|
print("------------------------------")
|
|
|
print(f"交易对{config.symbol}卖单较多，大于个{config.max_orders} 请处理")
|
|
|
|
|
|
#集中处理 buy_delete_orders sell_delete_orders
|
|
|
for buy_order in buy_delete_orders:
|
|
|
if self.cancel_single_order(buy_order):
|
|
|
if buy_order in buy_delete_orders:
|
|
|
buy_delete_orders.remove(buy_order)
|
|
|
for sell_order in sell_delete_orders:
|
|
|
if self.cancel_single_order(sell_order):
|
|
|
if sell_order in sell_delete_orders:
|
|
|
sell_delete_orders.remove(sell_order)
|
|
|
|
|
|
print(f"{utility.cn_time()} 第{self.loop_counts}轮循环结束 休息{self.sleep_time}s") |
