print('ooo') exit(0) # 取得当前账户信息 print("取得当前账户信息: ") acinfo = fcoin.get_balance() print(acinfo) sfile = '{0}_{1}'.format(stime, 'acbalance.csv') sfilepath = os.path.join(sDir,sfile) dataframe = pd.DataFrame(acinfo,index=[0]) dataframe.to_csv(sfilepath,index=False,sep=',') exit(0) # symbol 表示对应交易币种. 所有币种区分的 topic 都在 topic 末尾 print('取得symbol: ') syminfo = fcoin.get_symbols() rFind = False sfile = '{0}_{1}'.format(stime, 'allsyminfo.csv') sfilepath = os.path.join(sDir,sfile) sflag = 'amount_decimal' for ones in syminfo: print(ones) if os.path.exists(sfilepath): with open(sfilepath, 'r', encoding='utf-8') as f: first_line = f.readline() # 取第一行 rFind = sflag in first_line with open(sfilepath, 'a+', encoding='utf-8', newline='') as f: w = csv.writer(f) if rFind is True: vlist = list(ones.values()) w.writerow(vlist)
class ArbitrageRobot(object): """docstring for Robot""" def __init__(self): self.fcoin = Fcoin(api_key, api_secret) self.price_decimals = {} self.amount_decimals = {} self.tickers = {} pd.set_option('precision', 10) self.time_last_call = time.time() # 截取指定小数位数 def trunc(self, f, n): return round(f, n) # return math.floor(f*10**n)/10**n def ticker_handler(self, message): # print(message) if 'ticker' in message: symbol = message['type'].split('.')[1] self.tickers[symbol] = message['ticker'] ticker_queue.put(self.tickers, block=False) logging.debug("get ticker") # logging.info("ticker message: {}".format(message)) else: logging.debug("ticker message: {}".format(message)) def symbols_action(self): all_symbols = self.fcoin.get_symbols() for symbol in symbol_pairs: for info in all_symbols: if symbol == info['name']: self.price_decimals[symbol] = int(info['price_decimal']) self.amount_decimals[symbol] = int(info['amount_decimal']) break logging.info("price_decimals: {}".format(self.price_decimals)) logging.info("amount_decimals: {}".format(self.amount_decimals)) # 买操作 def buy_action(self, this_symbol, this_price, this_amount, type="limit"): # this_price = self.trunc(this_price, self.price_decimals[this_symbol]) this_amount = self.trunc(this_amount, self.amount_decimals[this_symbol]) buy_result = self.fcoin.buy(this_symbol, this_price, this_amount, type) # print('buy_result is', buy_result) buy_order_id = buy_result['data'] if buy_order_id: lprint("买单 {} 价格成功委托, 订单ID {}".format(this_price, buy_order_id)) return buy_order_id # 卖操作 def sell_action(self, this_symbol, this_price, this_amount, type="limit"): # this_price = self.trunc(this_price, self.price_decimals[this_symbol]) this_amount = self.trunc(this_amount, self.amount_decimals[this_symbol]) sell_result = self.fcoin.sell(this_symbol, this_price, this_amount, type) # print('sell_result is: ', sell_result) sell_order_id = sell_result['data'] if sell_order_id: lprint("卖单 {} 价格成功委托, 订单ID {}".format(this_price, sell_order_id)) return sell_order_id def strategy(self, type, pricedf, amount): # 从zipeth开始交易, 因为它成交量最小 # print('使用套利策略') self.time_last_call = time.time() if type == 1: # usdtamount = amount*pricedf["ethusdt"] zipamount = amount / pricedf["zipeth"] thread1 = threading.Thread(target=self.sell_action, args=("zipeth", pricedf["zipeth"], zipamount)) thread2 = threading.Thread(target=self.buy_action, args=("zipusdt", pricedf["zipusdt"], zipamount)) thread3 = threading.Thread(target=self.sell_action, args=("ethusdt", pricedf["ethusdt"], amount)) thread1.start() thread2.start() thread3.start() elif type == 2: zipamount = amount / pricedf["zipeth"] # usdtamount = amount*pricedf["ethusdt"] thread1 = threading.Thread(target=self.buy_action, args=("zipeth", pricedf["zipeth"], zipamount)) thread2 = threading.Thread(target=self.sell_action, args=("zipusdt", pricedf["zipusdt"], zipamount)) thread3 = threading.Thread(target=self.buy_action, args=("ethusdt", pricedf["ethusdt"], amount)) thread1.start() thread2.start() thread3.start() def trade(self, tickers=None): """套利策略,寻找一个三元pair,看是不是满足套利规则。 ETH/USDT, ZIP/ETH, ZIP/USDT ethusdt买一价 * zipeth买一价 / zipusdt卖一价, 如果大于1很多,就存在套利空间 操作流程:usdt买zip,卖zip换回eth,卖eth换回usdt zipusdt买一价 / zipeth卖一价 / ethusdt卖一价, 如果大于1很多,就存在套利空间 操作流程为:usdt买eth,eht买zip,卖zip换回usdt 买一下标为2, 卖一下标为4""" # time.sleep(second) amount = _ethamount self_tickers = tickers if tickers == None: self_tickers = self.tickers if len(self_tickers) == len(symbol_pairs): info_df = pd.DataFrame(self_tickers).T # 买一卖一的均价 info_df["price"] = (info_df[2] + info_df[4]) / 2 taoli1 = info_df.loc["ethusdt", 2] * \ info_df.loc["zipeth", 2] / info_df.loc["zipusdt", 4] taoli2 = info_df.loc["zipusdt", 2] / \ info_df.loc["zipeth", 4] / info_df.loc["ethusdt", 4] if taoli1 > difference: info_df["price"] = info_df[2] info_df.loc["zipusdt", "price"] = info_df.loc["zipusdt", 4] if is_use_amount: if info_df.loc["ethusdt", 3] < _halfeth or info_df.loc[ "zipusdt", 5] < _halfzip or info_df.loc["zipeth", 3] < _halfzip: lprint('挂单量太小,本次无法套利 方式一', logging.DEBUG) return lprint("满足套利条件1 套利值为{:.4}‰".format(taoli1 * 1000 - 1000)) self.strategy(1, info_df.price, amount) lprint("zipeth卖价:{} zipusdt买价:{} ethusdt卖价:{}".format( info_df.price["zipeth"], info_df.price["zipusdt"], info_df.price["ethusdt"])) time.sleep(second) elif taoli2 > difference: info_df["price"] = info_df[4] info_df.loc["zipusdt", "price"] = info_df.loc["zipusdt", 2] if is_use_amount: if info_df.loc["ethusdt", 5] < _halfeth or info_df.loc[ "zipusdt", 3] < _halfzip or info_df.loc["zipeth", 5] < _halfzip: lprint('挂单量太小,本次无法套利 方式二', logging.DEBUG) return # else: # if is_mutable_amount: # amount = min(rates) * amount # if amount > maxamount: # amount = maxamount # lprint("每单金额{}eth,最小利差{:.2}‰".format(amount, (difference-1)*1000)) lprint("满足套利条件2 套利值比为{:.4}‰".format(taoli2 * 1000 - 1000)) self.strategy(2, info_df.price, amount) lprint("zipeth买价:{} zipusdt卖价:{} ethusdt买价:{}".format( info_df.price["zipeth"], info_df.price["zipusdt"], info_df.price["ethusdt"])) time.sleep(second) else: lprint('差价太小,本次无法套利 方式一{} 方式二{}'.format(taoli1, taoli2), logging.DEBUG) if time.time() - self.time_last_call > heartbeat_interval: self.time_last_call = time.time() thread1 = threading.Thread(target=self.fcoin.get_server_time) thread2 = threading.Thread(target=self.fcoin.get_server_time) thread3 = threading.Thread(target=self.fcoin.get_server_time) thread1.start() thread2.start() thread3.start() def run(self): self.symbols_action() # self.get_balance_action(symbols) balance.balance() self.client = fcoin_client(self.on_close) self.client.start() self.client.subscribe_tickers(symbol_pairs, self.ticker_handler) while True: tickers = ticker_queue.get() self.trade(tickers) ticker_queue.queue.clear() def on_close(self): print("websocket closed, try to restart...") time.sleep(second) self.client = fcoin_client(self.on_close) self.client.start() self.client.subscribe_tickers(symbol_pairs, self.ticker_handler)
from fcoin import Fcoin #if python3 use fcoin3 #from fcoin3 import Fcoin fcoin = Fcoin() print(fcoin.get_symbols()) print(fcoin.get_currencies()) fcoin.auth('you-key', 'you-secret') print(fcoin.get_balance()) print(fcoin.buy('fteth', 0.0001, 10)) #print(fcoin.sell('fteth', 0.002, 5)) #print(fcoin.cancel_order('6TfBZ-eORp4_2nO5ar6zhg0gLLvuWzTTmL1OzOy9OYg=')) #print(fcoin.get_candle('M1','fteth'))
class ArbitrageRobot(object): """docstring for Robot""" def __init__(self): self.fcoin = Fcoin(api_key, api_secret) self.price_decimals = {} self.amount_decimals = {} self.tickers = {} self.time_last_call = time.time() # 截取指定小数位数 def trunc(self, f, n): return round(f, n) # return math.floor(f*10**n)/10**n def ticker_handler(self, message): if 'ticker' in message: symbol = message['type'].split('.')[1] self.tickers[symbol] = message['ticker'] ticker_queue.put(self.tickers, block=False) logging.debug("get ticker") # logging.info("ticker message: {}".format(message)) else: logging.debug("ticker message: {}".format(message)) def symbols_action(self): all_symbols = self.fcoin.get_symbols() for symbol in symbol_pairs: for info in all_symbols: if symbol == info['name']: self.price_decimals[symbol] = int(info['price_decimal']) self.amount_decimals[symbol] = int(info['amount_decimal']) break logging.info("price_decimals: {}".format(self.price_decimals)) logging.info("amount_decimals: {}".format(self.amount_decimals)) # 买操作 def buy_action(self, this_symbol, this_price, this_amount, type="limit"): # this_price = self.trunc(this_price, self.price_decimals[this_symbol]) this_amount = self.trunc(this_amount, self.amount_decimals[this_symbol]) buy_result = self.fcoin.buy(this_symbol, this_price, this_amount, type) buy_order_id = buy_result['data'] if buy_order_id: logging.info("买单 {} 价格成功委托, 订单ID {}".format( this_price, buy_order_id)) return buy_order_id # 卖操作 def sell_action(self, this_symbol, this_price, this_amount, type="limit"): # this_price = self.trunc(this_price, self.price_decimals[this_symbol]) this_amount = self.trunc(this_amount, self.amount_decimals[this_symbol]) sell_result = self.fcoin.sell(this_symbol, this_price, this_amount, type) sell_order_id = sell_result['data'] if sell_order_id: logging.info("卖单 {} 价格成功委托, 订单ID {}".format( this_price, sell_order_id)) return sell_order_id def strategy(self, type, pricedf, amount): self.time_last_call = time.time() if type == 1: s1amount = amount / pricedf[sp1] thread1 = threading.Thread(target=self.sell_action, args=(sp1, pricedf[sp1], s1amount)) thread2 = threading.Thread(target=self.buy_action, args=(sp2, pricedf[sp2], s1amount)) thread3 = threading.Thread(target=self.sell_action, args=(sp3, pricedf[sp3], amount)) thread1.start() thread2.start() thread3.start() elif type == 2: s1amount = amount / pricedf[sp1] thread1 = threading.Thread(target=self.buy_action, args=(sp1, pricedf[sp1], s1amount)) thread2 = threading.Thread(target=self.sell_action, args=(sp2, pricedf[sp2], s1amount)) thread3 = threading.Thread(target=self.buy_action, args=(sp3, pricedf[sp3], amount)) thread1.start() thread2.start() thread3.start() def trade(self, tickers=None): """套利策略,寻找一个三元pair,看是不是满足套利规则。 ETH/USDT, FI/ETH, FI/USDT ethusdt买一价 * fieth买一价 / fiusdt卖一价, 如果大于1很多,就存在套利空间 操作流程:usdt买fi,卖fi换回eth,卖eth换回usdt fiusdt买一价 / fieth卖一价 / ethusdt卖一价, 如果大于1很多,就存在套利空间 操作流程为:usdt买eth,eht买fi,卖fi换回usdt 买一下标为2, 卖一下标为4""" # time.sleep(sleepsecond) amount = _s2amount self_tickers = tickers if len(self_tickers) == len(symbol_pairs): taoli1 = self_tickers[sp3][2] * \ self_tickers[sp1][2] / self_tickers[sp2][4] taoli2 = self_tickers[sp2][2] / \ self_tickers[sp1][4] / self_tickers[sp3][4] if taoli1 > difference: pricedf = { sp3: self_tickers[sp3][2], sp2: self_tickers[sp2][4], sp1: self_tickers[sp1][2] } if is_use_amount: if self_tickers[sp3][3] < halfs2 or self_tickers[sp2][ 5] < halfs1 or self_tickers[sp1][3] < halfs1: logging.debug('挂单量太小,本次无法套利 方式一') return logging.info("满足套利条件1 套利值为{:.4}‰".format(taoli1 * 1000 - 1000)) self.strategy(1, pricedf, amount) logging.info("{}卖价:{} {}买价:{} {}卖价:{}".format( sp1, pricedf[sp1], sp2, pricedf[sp2], sp3, pricedf[sp3])) time.sleep(sleepsecond) print("满足套利条件1 套利值为{:.4}‰".format(taoli1 * 1000 - 1000)) elif taoli2 > difference: pricedf = { sp3: self_tickers[sp3][4], sp2: self_tickers[sp2][2], sp1: self_tickers[sp1][4] } if is_use_amount: if self_tickers[sp3][5] < halfs2 or self_tickers[sp2][ 3] < halfs1 or self_tickers[sp1][5] < halfs1: logging.debug('挂单量太小,本次无法套利 方式二') return logging.info("满足套利条件2 套利值比为{:.4}‰".format(taoli2 * 1000 - 1000)) self.strategy(2, pricedf, amount) logging.info("{}买价:{} {}卖价:{} {}买价:{}".format( sp1, pricedf[sp1], sp2, pricedf[sp2], sp3, pricedf[sp3])) time.sleep(sleepsecond) print("满足套利条件2 套利值比为{:.4}‰".format(taoli2 * 1000 - 1000)) else: logging.debug('差价太小,本次无法套利 方式一{} 方式二{}'.format(taoli1, taoli2)) print('差价太小,本次无法套利 方式一{} 方式二{}'.format(taoli1, taoli2)) else: time.sleep(sleepsecond) return if time.time() - self.time_last_call > heartbeat_interval: self.time_last_call = time.time() thread1 = threading.Thread(target=self.fcoin.get_server_time) thread2 = threading.Thread(target=self.fcoin.get_server_time) thread3 = threading.Thread(target=self.fcoin.get_server_time) thread1.start() thread2.start() thread3.start() def run(self): self.symbols_action() # self.get_balance_action(symbols) balance.balance(symbols) self.client = fcoin_client(self.on_close) self.client.start() self.client.subscribe_tickers(symbol_pairs, self.ticker_handler) while True: tickers = ticker_queue.get() self.trade(tickers) ticker_queue.queue.clear() def on_close(self): print("websocket closed, try to restart...") time.sleep(sleepsecond) self.client = fcoin_client(self.on_close) self.client.start() self.client.subscribe_tickers(symbol_pairs, self.ticker_handler)
class Robot(object): """docstring for Robot""" def __init__(self): self.fcoin = Fcoin(api_key, api_secret) # 截取指定小数位数 def trunc(self, f, n): return round(f, n) def ticker_handler(self, message): if 'ticker' in message: self.ticker = message['ticker'] # print('ticker', self.ticker) def symbols_action(self): all_symbols = self.fcoin.get_symbols() for info in all_symbols: if symbol == info['name']: self.price_decimal = int(info['price_decimal']) self.amount_decimal = int(info['amount_decimal']) print('price_decimal:', self.price_decimal, 'amount_decimal:', self.amount_decimal) return # 查询账户余额 def get_balance_action(self, symbols, specfic_symbol = None): balance_info = self.fcoin.get_balance() specfic_balance = 0 for info in balance_info['data']: for symbol in symbols: if info['currency'] == symbol: balance = info print(balance['currency'], '账户余额', balance['balance'], '可用', balance['available'], '冻结', balance['frozen']) if info['currency'] == specfic_symbol: specfic_balance = float(info['available']) return specfic_balance # 买操作 def buy_action(self, this_symbol, this_price, this_amount, should_repeat = 0): ticker = self.ticker print('准备买入', this_price, ticker) buy_result = self.fcoin.buy(this_symbol, self.trunc(this_price, self.price_decimal), this_amount) print('buy_result is', buy_result) buy_order_id = buy_result['data'] if buy_order_id: print('买单', this_price, '价格成功委托', '订单ID', buy_order_id) return buy_order_id # 卖操作 def sell_action(self, this_symbol, this_price, this_amount): ticker = self.ticker print('准备卖出', this_price, ticker) if is_direct_buy == 1: sell_result = self.fcoin.sell(this_symbol, self.trunc(this_price * (1 - 0.0002), self.price_decimal), this_amount) else: sell_result = self.fcoin.sell(this_symbol, this_price, this_amount) print('sell_result is: ', sell_result) sell_order_id = sell_result['data'] if sell_order_id: print('卖单', this_price, '价格成功委托', '订单ID', sell_order_id) return sell_order_id def strategy(self, symbol, order_price, amount): print('使用单边震荡策略') buy_id = self.buy_action(symbol, order_price, amount) sell_id = self.sell_action(symbol, order_price, amount) def trade(self): time.sleep(second) print(bytes.decode(base64.b64decode(b'6LSt5Lmw6K+36K6k5YeG5b6u5L+h5Y+3YXJjaGVyemhz77yM5LiN6KaB55u45L+h5YW25LuW55qE5p2l5rqQ'))) ticker = self.ticker newest_price = ticker[0] high_bids = ticker[2] high_bids_amount = ticker[3] low_ask = ticker[4] low_ask_amount = ticker[5] order_price = self.trunc((low_ask + high_bids) / 2, self.price_decimal) real_price_difference = float(low_ask - high_bids) print('最低卖价:', low_ask, '最高买价', high_bids, '欲下订单价: ', order_price, '当前差价:', '{:.9f}'.format(real_price_difference), '设定差价:', '{:.9f}'.format(price_difference)) if real_price_difference > price_difference: print('现在价格:', newest_price, '挂单价格', order_price) self.strategy(symbol, order_price, amount) else: print('差价太小,放弃本次成交') def run(self): self.client = fcoin_client() self.client.start() self.client.subscribe_ticker(symbol, self.ticker_handler) self.symbols_action() self.get_balance_action(symbols) while True: self.trade()
class Robot(object): logging.basicConfig(filename='logger.log', level=logging.WARN) """docstring for Robot""" def __init__(self): self.fcoin = Fcoin(api_key, api_secret) # 截取指定小数位数 def trunc(self, f, n): return round(f, n) def ticker_handler(self, message): if 'ticker' in message: self.ticker = message['ticker'] # print('ticker', self.ticker) def symbols_action(self): all_symbols = self.fcoin.get_symbols() for info in all_symbols: if symbol == info['name']: self.price_decimal = int(info['price_decimal']) self.amount_decimal = int(info['amount_decimal']) print('price_decimal:', self.price_decimal, 'amount_decimal:', self.amount_decimal) return # 查询账户余额 def get_balance_action(self, symbols, specfic_symbol=None): balance_info = self.fcoin.get_balance() specfic_balance = 0 for info in balance_info['data']: for symbol in symbols: if info['currency'] == symbol: balance = info print(balance['currency'], '账户余额', balance['balance'], '可用', balance['available'], '冻结', balance['frozen']) if info['currency'] == specfic_symbol: specfic_balance = float(info['available']) return specfic_balance # 买操作 def buy_action(self, this_symbol, this_price, this_amount, diff, should_repeat=0): ticker = self.ticker cur_price = str(self.trunc(this_price - diff, self.price_decimal)) print('准备买入', this_price, ticker) buy_result = self.fcoin.buy(this_symbol, cur_price, str(this_amount)) print('buy_result is', buy_result) buy_order_id = buy_result['data'] if buy_order_id: print('++++++++++++++++++++++++++++买单: ' + cur_price + '价格成功委托, 订单ID: ' + buy_order_id) logging.warning('买单: ' + cur_price + '价格成功委托, 订单ID: ' + buy_order_id) return buy_order_id # 卖操作 def sell_action(self, this_symbol, this_price, this_amount, diff): ticker = self.ticker cur_price = str(self.trunc(this_price + diff, self.price_decimal)) print('准备卖出', cur_price, ticker) sell_result = self.fcoin.sell(this_symbol, cur_price, str(this_amount)) print('sell_result is: ', sell_result) sell_order_id = sell_result['data'] if sell_order_id: print('----------------------------卖单: ' + cur_price + '价格成功委托, 订单ID: ' + sell_order_id) logging.warning('卖单: ' + cur_price + '价格成功委托, 订单ID: ' + sell_order_id) return sell_order_id def list_active_orders(self, this_symbol, state='submitted'): dt = datetime(fees_start_time['year'], fees_start_time['month'], fees_start_time['day'], fees_start_time['hour'], fees_start_time['minute'], fees_start_time['second']) timestamp = int(dt.timestamp() * 1000) return self.fcoin.list_orders(symbol=this_symbol, states=state, after=timestamp) def get_order_count(self, this_symbol): order_list = self.list_active_orders(this_symbol) order_buy = 0 order_sell = 0 price_buy_max = 0 price_buy_min = 655350 id_buy_min = "" price_sell_min = 655350 price_sell_max = 0 id_sell_max = "" for i in range(len(order_list['data'])): price_cur = float(order_list['data'][i]['price']) if order_list['data'][i]['side'] == 'buy': order_buy = order_buy + 1 if price_cur > price_buy_max: price_buy_max = price_cur if price_cur < price_buy_min: price_buy_min = price_cur id_buy_min = order_list['data'][i]['id'] else: order_sell = order_sell + 1 if price_cur < price_sell_min: price_sell_min = price_cur if price_cur > price_sell_max: price_sell_max = price_cur id_sell_max = order_list['data'][i]['id'] order_price_range = abs(price_sell_max - price_buy_min) print("buy_count:", order_buy, "buy_min:", price_buy_min, "buy_max:", price_buy_max, "sell_count:", order_sell, "sell_min", price_sell_min, "sell_max", price_sell_max, "order_price_range", order_price_range) return (order_buy, price_buy_max, id_buy_min, order_sell, price_sell_min, id_sell_max, order_price_range) def adjust(self, real_diff, order_price): diff = order_price * price_diff if (diff < real_diff): diff = real_diff buy_diff = diff sell_diff = diff return (buy_diff, sell_diff) def strategy(self, symbol, order_price, amount, real_diff): order_buy, price_buy_max, id_buy_min, order_sell, price_sell_min, id_sell_max, order_price_range = self.get_order_count( symbol) if (order_price_range > trade_range): if (order_buy > order_sell + order_count_diff): if "" != id_buy_min: print("order_price_range:", order_price_range, "buy_order_cancel:", id_buy_min) self.fcoin.cancel_order(id_buy_min) if (order_sell > order_buy + order_count_diff): if "" != id_sell_max: print("order_price_range", order_price_range, "sell_order_cancel:", id_sell_max) self.fcoin.cancel_order(id_sell_max) buy_diff, sell_diff = self.adjust(real_diff, order_price) cur_price_range = price_range * order_price if ((price_buy_max + cur_price_range) < order_price): try: buy_id = self.buy_action(symbol, order_price, amount, buy_diff) except Exception as err: print("failed to buy", err) if ((price_sell_min - cur_price_range) > order_price): try: sell_id = self.sell_action(symbol, order_price, amount, sell_diff) except Exception as err: print("failed to sell", err) def trade(self): time.sleep(second) ticker = self.ticker newest_price = ticker[0] high_bids = ticker[2] high_bids_amount = ticker[3] low_ask = ticker[4] low_ask_amount = ticker[5] order_price = self.trunc((low_ask + high_bids) / 2, self.price_decimal) real_price_difference = float(low_ask - high_bids) print('最低卖价:', low_ask, '最高买价', high_bids, '欲下订单价: ', order_price, '当前差价:', '{:.9f}'.format(real_price_difference), '设定差价:', '{:.9f}'.format(price_difference)) if real_price_difference > price_difference: print('现在价格:', newest_price, '挂单价格', order_price) self.strategy(symbol, order_price, amount, real_price_difference / 2) else: print('差价太小,放弃本次成交') def run(self): self.client = fcoin_client() self.client.start() self.client.subscribe_ticker(symbol, self.ticker_handler) self.symbols_action() self.get_balance_action(symbols) time = 0 while True: self.trade() time = time + 1 if (time > 100): break
cf.read("fcoin.conf") key = cf.get('api', 'key') secret = cf.get('api', 'secret') symbol = cf.get('brush', 'symbol') currency = cf.get('brush', 'currency') addr = cf.get('peer', 'addr') server_port = cf.get('peer', 'server_port') peer_port = cf.get('peer', 'peer_port') actor = cf.get('peer', 'actor') except Exception: print('please check the config file <fcoin.conf> in parent direction') exit(1) fcoin = Fcoin() fcoin.auth(key, secret) symbols = fcoin.get_symbols() send_queue = Queue.Queue(maxsize=1) recv_queue = Queue.Queue(maxsize=1) udp_socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) udp_socket.bind((addr, int(server_port))) serial = 0 class Sender(threading.Thread): def run(self): while True: data_obj = send_queue.get() data = pickle.dumps(data_obj) udp_socket.sendto(data.encode('utf-8'), (addr, int(peer_port))) print('send data=%s to address=%s' % (str(data_obj), addr))
class ArbitrageRobot(object): """docstring for Robot""" def __init__(self): self.fcoin = Fcoin(api_key, api_secret) self.price_decimals = {} self.amount_decimals = {} self.tickers = {} # 截取指定小数位数 def trunc(self, f, n): # return round(f, n) return math.floor(f * 10**n) / 10**n def ticker_handler(self, message): # print(message) if 'ticker' in message: symbol = message['type'].split('.')[1] self.tickers[symbol] = message['ticker'] logging.debug("ticker: {}".format(message['ticker'])) else: logging.debug("ticker message: {}".format(message)) def symbols_action(self): all_symbols = self.fcoin.get_symbols() for symbol in symbol_pairs: for info in all_symbols: if symbol == info['name']: self.price_decimals[symbol] = int(info['price_decimal']) self.amount_decimals[symbol] = int(info['amount_decimal']) break logging.info("price_decimals: {}".format(self.price_decimals)) # 买操作 def buy_action(self, this_symbol, this_price, this_amount, should_repeat=0): this_price = self.trunc(this_price, self.price_decimals[this_symbol]) this_amount = self.trunc(this_amount, self.amount_decimals[this_symbol]) # ticker = self.tickers[this_symbol] # print('准备买入', this_price, ticker) buy_result = self.fcoin.buy(this_symbol, this_price, this_amount) # print('buy_result is', buy_result) buy_order_id = buy_result['data'] if buy_order_id: lprint("买单 {} 价格成功委托, 订单ID {}".format(this_price, buy_order_id)) return buy_order_id # 卖操作 def sell_action(self, this_symbol, this_price, this_amount): this_price = self.trunc(this_price, self.price_decimals[this_symbol]) this_amount = self.trunc(this_amount, self.amount_decimals[this_symbol]) # ticker = self.tickers[this_symbol] # print('准备卖出', this_price, ticker) sell_result = self.fcoin.sell(this_symbol, this_price, this_amount) # print('sell_result is: ', sell_result) sell_order_id = sell_result['data'] if sell_order_id: lprint("卖单 {} 价格成功委托, 订单ID {}".format(this_price, sell_order_id)) return sell_order_id def strategy(self, type, pricedf, amount): print('使用套利策略') if type == 1: usdtamount = amount * pricedf["ethusdt"] ftamount = usdtamount / pricedf["ftusdt"] self.sell_action("fteth", pricedf["fteth"], ftamount) self.buy_action("ftusdt", pricedf["ftusdt"], ftamount) self.sell_action("ethusdt", pricedf["ethusdt"], amount) elif type == 2: ftamount = amount / pricedf["fteth"] self.buy_action("ethusdt", pricedf["ethusdt"], amount) self.sell_action("ftusdt", pricedf["ftusdt"], ftamount) self.buy_action("fteth", pricedf["fteth"], ftamount) def trade(self): """套利策略,寻找一个三元pair,看是不是满足套利规则。 ETH/USDT, FT/ETH, FT/USDT ethusdt买一价 * fteth买一价 / ftusdt卖一价, 如果大于1很多,就存在套利空间 操作流程:usdt买ft,卖ft换回eth,卖eth换回usdt ftusdt买一价 / fteth卖一价 / ethusdt卖一价, 如果大于1很多,就存在套利空间 操作流程为:usdt买eth,eht买ft,卖ft换回usdt 买一下标为2, 卖一下标为4""" time.sleep(second) if len(self.tickers) == len(symbol_pairs): info_df = pd.DataFrame(self.tickers).T # 买一卖一的均价 info_df["price"] = (info_df[2] + info_df[4]) / 2 taoli1 = info_df.price["ethusdt"] * \ info_df.price["fteth"] / info_df.price["ftusdt"] taoli2 = info_df.price["ftusdt"] / \ info_df.price["fteth"] / info_df.price["ethusdt"] # print(taoli1, taoli2) # 从eth开始交易 if taoli1 > difference: self.strategy(1, info_df.price, ethamount) lprint("满足套利条件1 套利值为{:.4}‰".format(taoli1 * 1000 - 1000)) lprint("ethusdt卖价:{} ftusdt买价:{} fteth卖价:{}".format( info_df.price["ethusdt"], info_df.price["ftusdt"], info_df.price["fteth"])) elif taoli2 > difference: self.strategy(2, info_df.price, ethamount) lprint("满足套利条件2 套利值比为{:.4}‰".format(taoli2 * 1000 - 1000)) lprint("fteth买价:{} ftusdt卖价:{} ethusdt买价:{}".format( info_df.price["fteth"], info_df.price["ftusdt"], info_df.price["ethusdt"])) else: lprint('差价太小,本次无法套利 方式一{} 方式二{}'.format(taoli1, taoli2), logging.DEBUG) def run(self): self.client = fcoin_client() self.client.start() self.client.subscribe_tickers(symbol_pairs, self.ticker_handler) self.symbols_action() # self.get_balance_action(symbols) balance.balance() while True: self.trade()
class Robot(object): """docstring for Robot""" def __init__(self): self.fcoin = Fcoin(api_key, api_secret) # self.ticker = [] self.time_since_last_call = 0 # 截取指定小数位数 def trunc(self, f, n): # return round(f, n) return math.floor(f * 10**n) / 10**n def ticker_handler(self, message): if 'ticker' in message: self.ticker = message['ticker'] # print('ticker', self.ticker) def symbols_action(self): all_symbols = self.fcoin.get_symbols() for info in all_symbols: if symbol == info['name']: self.price_decimal = int(info['price_decimal']) self.amount_decimal = int(info['amount_decimal']) # print('price_decimal:', self.price_decimal, 'amount_decimal:', self.amount_decimal) return # 查询账户余额 def get_balance_action(self, symbols, specfic_symbol=None): balance_info = self.fcoin.get_balance() specfic_balance = 0 for info in balance_info['data']: for symbol in symbols: if info['currency'] == symbol: balance = info print(balance['currency'], '账户余额', balance['balance'], '可用', balance['available'], '冻结', balance['frozen']) if info['currency'] == specfic_symbol: specfic_balance = float(info['available']) return specfic_balance # 买操作 def buy_action(self, this_symbol, this_price, this_amount, should_repeat=0): # ticker = self.ticker # print('准备买入', this_price, ticker) buy_result = self.fcoin.buy(this_symbol, self.trunc(this_price, self.price_decimal), this_amount) # print('buy_result is', buy_result) buy_order_id = buy_result['data'] if buy_order_id: lprint('买单{} 价格成功委托 订单ID{}'.format(this_price, buy_order_id)) return buy_order_id # 卖操作 def sell_action(self, this_symbol, this_price, this_amount): # ticker = self.ticker # print('准备卖出', this_price, ticker) sell_result = self.fcoin.sell(this_symbol, this_price, this_amount) # print('sell_result is: ', sell_result) sell_order_id = sell_result['data'] if sell_order_id: lprint('卖单{} 价格成功委托 订单ID{}'.format(this_price, sell_order_id)) return sell_order_id def strategy(self, symbol, order_price, amount, gap): # print('使用单边震荡策略') # lprint("start strategy", logging.DEBUG) buy_price = self.trunc(order_price - gap, self.price_decimal) sell_price = self.trunc(order_price + gap, self.price_decimal) if is_multi_thread: buy_thread = threading.Thread(target=self.buy_action, args=(symbol, buy_price, amount)) sell_thread = threading.Thread(target=self.sell_action, args=(symbol, sell_price, amount)) buy_thread.start() sell_thread.start() else: self.buy_action(symbol, buy_price, amount) self.sell_action(symbol, sell_price, amount) def trade(self): time.sleep(second) ticker = self.ticker # if len(ticker) == 0: # return # newest_price = ticker[0] high_bids = ticker[2] high_bids_amount = ticker[3] low_ask = ticker[4] low_ask_amount = ticker[5] order_price = (low_ask + high_bids) / 2 real_price_difference = float(low_ask - high_bids) if real_price_difference > price_difference: gap = 0 if is_mutable_gap: gap = real_price_difference / 3 elif is_using_gap: gap = price_difference / 3 # print('现在价格:', newest_price, '挂单价格', order_price) lprint('最低卖价: {} 最高买价: {} 当前差价:{:.9f} 买卖差价: {:.9f}'.format( low_ask, high_bids, real_price_difference, gap * 2)) if is_mutable_amount: trade_amount = min(high_bids_amount, low_ask_amount) / 2 if trade_amount > maxamount: trade_amount = maxamount if trade_amount < miniamount: trade_amount = miniamount trade_amount = self.trunc(trade_amount, self.amount_decimal) self.strategy(symbol, order_price, trade_amount, gap) else: self.strategy(symbol, order_price, amount, gap) self.time_since_last_call = 0 else: print('最低卖价: {} 最高买价: {} 当前差价:{:.9f} 设定差价: {:.9f}'.format( low_ask, high_bids, real_price_difference, price_difference)) print('差价太小,放弃本次成交') self.time_since_last_call += second if self.time_since_last_call > heartbeat_interval: # inorder to keep-alive if is_multi_thread: buy_thread = threading.Thread( target=self.fcoin.get_server_time) sell_thread = threading.Thread( target=self.fcoin.get_server_time) buy_thread.start() sell_thread.start() else: self.fcoin.get_server_time() self.time_since_last_call = 0 def run(self): self.client = fcoin_client(self.on_close) # self.client = fcoin_client() self.client.start() self.client.subscribe_tickers([symbol], self.ticker_handler) self.symbols_action() # self.get_balance_action(symbols) if not is_mutable_amount: logging.info("交易标的:{} 每单交易量:{} {}".format(symbol, amount, symbols[0])) balance.balance() while True: self.trade() def on_close(self): print("websocket closed, try to restart...") time.sleep(second) # self.client = fcoin_client(self.on_close) self.client.start() self.client.subscribe_tickers([symbol], self.ticker_handler)