def sell_by_exchange(trade):
res = STATUS.FAILURE, None
assert_trade_type(trade, DEAL_TYPE.SELL)
key = get_key_by_exchange(trade.exchange_id)
methods_by_exchange = {
EXCHANGE.BITTREX:
(get_currency_pair_to_bittrex, add_sell_order_bittrex),
EXCHANGE.KRAKEN: (get_currency_pair_to_kraken, add_sell_order_kraken),
EXCHANGE.POLONIEX:
(get_currency_pair_to_poloniex, add_sell_order_poloniex),
EXCHANGE.BINANCE:
(get_currency_pair_to_binance, add_sell_order_binance),
EXCHANGE.HUOBI: (get_currency_pair_to_huobi, add_sell_order_huobi)
}
if trade.exchange_id in methods_by_exchange:
get_currency_pair, add_sell_order = methods_by_exchange[
trade.exchange_id]
currency = get_currency_pair(trade.pair_id)
res = add_sell_order(key, currency, trade.price, trade.volume)
else:
log_error_unknown_exchange("sell_by_exchange", trade)
return res
def test_trade_history_huobi_methods():
load_keys(API_KEY_PATH)
key = get_key_by_exchange(EXCHANGE.HUOBI)
time_end = get_now_seconds_utc()
time_start = 0 # time_end - POLL_TIMEOUT
pair_name = get_currency_pair_to_huobi(CURRENCY_PAIR.BTC_TO_LSK)
huobi_orders_by_pair = get_order_history_huobi(key, pair_name, time_start,
time_end)
for pair_id in huobi_orders_by_pair:
pair_name = get_currency_pair_to_huobi(pair_id)
print "PAIR NAME: ", pair_name
for b in huobi_orders_by_pair[pair_id]:
print b
res, order_history = get_order_history_huobi(key, pair_name, time_start,
time_end)
if len(order_history) > 0:
for b in order_history:
print b
pg_conn = init_pg_connection(_db_host=DB_HOST,
_db_port=DB_PORT,
_db_name=DB_NAME)
load_recent_huobi_trades_to_db(pg_conn,
time_start,
time_end,
unique_only=True)
def test_poloniex_doge():
if not YES_I_KNOW_WHAT_AM_I_DOING:
die_hard("test_poloniex_doge may issue a real trade!")
load_keys(API_KEY_PATH)
key = get_key_by_exchange(EXCHANGE.POLONIEX)
pair_id = CURRENCY_PAIR.BTC_TO_DGB
pair_name = get_currency_pair_name_by_exchange_id(pair_id,
EXCHANGE.POLONIEX)
err, json_repr = add_buy_order_poloniex(key,
pair_name,
price=0.00000300,
amount=100)
print json_repr
def test_binance_xlm():
if not YES_I_KNOW_WHAT_AM_I_DOING:
die_hard("test_binance_xlm may issue a real trade!")
load_keys(API_KEY_PATH)
key = get_key_by_exchange(EXCHANGE.BINANCE)
pair_id = CURRENCY_PAIR.BTC_TO_XLM
pair_name = get_currency_pair_name_by_exchange_id(pair_id,
EXCHANGE.BINANCE)
err, json_repr = add_buy_order_binance(key,
pair_name,
price=0.00003000,
amount=100)
print json_repr
def test_bittrex_strat():
if not YES_I_KNOW_WHAT_AM_I_DOING:
die_hard("test_bittrex_strat may issue a real trade!")
key = get_key_by_exchange(EXCHANGE.BITTREX)
pair_id = CURRENCY_PAIR.BTC_TO_STRAT
pair_name = get_currency_pair_name_by_exchange_id(pair_id,
EXCHANGE.BITTREX)
err, json_repr = add_buy_order_bittrex(key,
pair_name,
price=0.0007,
amount=10)
print json_repr
err, json_repr = add_sell_order_bittrex(key,
pair_name,
price=0.0015,
amount=10)
print json_repr
def get_recent_bittrex_trades(start_time=START_OF_TIME,
end_time=get_now_seconds_utc()):
key = get_key_by_exchange(EXCHANGE.BITTREX)
bittrex_order_by_pair = defaultdict(list)
for pair_name in BITTREX_CURRENCY_PAIRS:
err_code, trades = get_order_history_bittrex(key, pair_name=pair_name)
while err_code == STATUS.FAILURE:
print "get_recent_bittrex_trades: got error responce - Reprocessing"
sleep_for(2)
err_code, trades = get_order_history_bittrex(key,
pair_name=pair_name)
for new_trade in trades:
if start_time <= new_trade.create_time <= end_time:
bittrex_order_by_pair[new_trade.pair_id].append(new_trade)
return bittrex_order_by_pair
def get_recent_binance_orders():
key = get_key_by_exchange(EXCHANGE.BINANCE)
binance_order = []
limit = 500
for pair_name in BINANCE_CURRENCY_PAIRS:
err_code, orders_by_pair = get_order_history_binance(
key, pair_name, limit)
print "Get data for ", pair_name
while err_code == STATUS.FAILURE:
sleep_for(2)
err_code, orders_by_pair = get_order_history_binance(
key, pair_name, limit)
binance_order += orders_by_pair
sleep_for(1)
return binance_order
def cancel_by_exchange(trade):
res = STATUS.FAILURE, None
key = get_key_by_exchange(trade.exchange_id)
methods_by_exchange = {
EXCHANGE.BITTREX: cancel_order_bittrex,
EXCHANGE.KRAKEN: cancel_order_kraken,
EXCHANGE.POLONIEX: cancel_order_poloniex,
EXCHANGE.HUOBI: cancel_order_huobi
}
if trade.exchange_id in methods_by_exchange:
res = methods_by_exchange[trade.exchange_id](key, trade.order_id)
elif trade.exchange_id == EXCHANGE.BINANCE:
pair_name = get_currency_pair_to_binance(trade.pair_id)
res = cancel_order_binance(key, pair_name, trade.order_id)
else:
log_error_unknown_exchange("cancel_by_exchange", trade)
return res
def get_open_orders_for_arbitrage_pair(cfg, processor):
open_orders = []
for exchange_id in [cfg.sell_exchange_id, cfg.buy_exchange_id]:
key = get_key_by_exchange(exchange_id)
pair_name = get_currency_pair_name_by_exchange_id(
cfg.pair_id, exchange_id)
method_for_url = get_open_orders_post_details_generator(exchange_id)
post_details = method_for_url(key, pair_name)
constructor = get_open_orders_constructor_by_exchange_id(exchange_id)
http_method = get_http_method_open_order_by_exchange_id(exchange_id)
wu = WorkUnit(post_details.final_url, constructor, pair_name)
wu.add_post_details(post_details)
wu.add_http_method(http_method)
open_orders.append(wu)
return processor.process_async_custom(open_orders, HTTP_TIMEOUT_SECONDS)
def get_recent_poloniex_trades(start_time=START_OF_TIME,
end_time=get_now_seconds_utc()):
key = get_key_by_exchange(EXCHANGE.POLONIEX)
poloniex_orders_by_pair = defaultdict(list)
for pair_name in POLONIEX_CURRENCY_PAIRS:
error_code, trades = get_order_history_poloniex(key,
pair_name=pair_name,
time_start=start_time)
while error_code != STATUS.SUCCESS:
print "get_recent_poloniex_trades: got error responce - Reprocessing"
sleep_for(2)
error_code, trades = get_order_history_poloniex(
key, pair_name=pair_name, time_start=start_time)
for trade in trades:
if start_time <= trade.create_time <= end_time:
poloniex_orders_by_pair[trade.pair_id].append(trade)
return poloniex_orders_by_pair
def get_recent_kraken_trades(start_time=START_OF_TIME,
end_time=get_now_seconds_utc()):
key = get_key_by_exchange(EXCHANGE.KRAKEN)
kraken_orders_by_pair = defaultdict(list)
error_code, trades = get_order_history_kraken(key,
pair_name=None,
time_start=start_time,
time_end=end_time)
while error_code != STATUS.SUCCESS:
print "get_recent_huobi_trades: got error responce - Reprocessing"
sleep_for(2)
error_code, trades = get_order_history_kraken(key,
pair_name=None,
time_start=start_time,
time_end=end_time)
for trade in trades:
if start_time <= trade.create_time <= end_time:
kraken_orders_by_pair[trade.pair_id].append(trade)
return kraken_orders_by_pair
def get_balance_by_exchange(exchange_id):
res = STATUS.FAILURE, None
key = get_key_by_exchange(exchange_id)
method_by_exchange = {
EXCHANGE.BITTREX: get_balance_bittrex,
EXCHANGE.KRAKEN: get_balance_kraken,
EXCHANGE.POLONIEX: get_balance_poloniex,
EXCHANGE.BINANCE: get_balance_binance,
EXCHANGE.HUOBI: get_balance_huobi
}
if exchange_id in method_by_exchange:
res = method_by_exchange[exchange_id](key)
_, balance = res
log_to_file(balance, "balance.log")
else:
msg = "get_balance_by_exchange - Unknown exchange_id! {idx}".format(
idx=exchange_id)
print_to_console(msg, LOG_ALL_ERRORS)
return res
def get_order_history_by_exchange(exchange_id, pair_id):
res = STATUS.FAILURE, None
key = get_key_by_exchange(exchange_id)
pair_name = get_currency_pair_name_by_exchange_id(pair_id, exchange_id)
method_by_exchange = {
EXCHANGE.BITTREX: get_order_history_bittrex,
EXCHANGE.KRAKEN: get_order_history_kraken,
EXCHANGE.POLONIEX: get_order_history_poloniex,
EXCHANGE.BINANCE: get_order_history_binance,
EXCHANGE.HUOBI: get_order_history_huobi
}
if exchange_id in method_by_exchange:
get_order_history = method_by_exchange[exchange_id]
res = get_order_history(key, pair_name)
else:
msg = "get_open_orders_by_exchange - Unknown exchange! {idx}".format(
idx=exchange_id)
print_to_console(msg, LOG_ALL_ERRORS)
return res
def init_deals_with_logging_speedy(trade_pairs, difference, file_name,
processor, msg_queue):
# FIXME move after deal placement ?
global overall_profit_so_far
overall_profit_so_far += trade_pairs.current_profit
base_currency_id, dst_currency_id = split_currency_pairs(
trade_pairs.deal_1.pair_id)
msg = """We try to send following deals to exchange.
<b>Expected profit in {base_coin}:</b> <i>{cur}</i>.
<b>Overall:</b> <i>{tot}</i>
<b>Difference in percents:</b> <i>{diff}</i>
Deal details:
{deal}
""".format(base_coin=get_currency_name_by_id(base_currency_id),
cur=float_to_str(trade_pairs.current_profit),
tot=float_to_str(overall_profit_so_far),
diff=difference,
deal=str(trade_pairs))
msg_queue.add_message(DEAL_INFO_MSG, msg)
log_to_file(msg, file_name)
if not YES_I_KNOW_WHAT_AM_I_DOING:
die_hard("init_deals_with_logging_speedy called for {f}".format(
f=trade_pairs))
parallel_deals = []
for order in [trade_pairs.deal_1, trade_pairs.deal_2]:
method_for_url = dao.get_method_for_create_url_trade_by_exchange_id(
order)
# key, pair_name, price, amount
key = get_key_by_exchange(order.exchange_id)
pair_name = get_currency_pair_name_by_exchange_id(
order.pair_id, order.exchange_id)
post_details = method_for_url(key, pair_name, order.price,
order.volume)
constructor = return_with_no_change
wu = WorkUnit(post_details.final_url, constructor, order)
wu.add_post_details(post_details)
parallel_deals.append(wu)
res = processor.process_async_post(parallel_deals, DEAL_MAX_TIMEOUT)
if res is None:
log_to_file(
"For TradePair - {tp} result is {res}".format(tp=trade_pairs,
res=res), file_name)
log_to_file(
"For TradePair - {tp} result is {res}".format(tp=trade_pairs,
res=res),
ERROR_LOG_FILE_NAME)
return
# check for errors only
for entry in res:
json_response, order = entry
if "ERROR" in json_response:
msg = """ <b>ERROR: </b>NONE
During deal placement: {u1}
Details: {err_msg}
""".format(u1=order, err_msg=json_response)
msg_queue.add_order(FAILED_ORDERS_MSG, order)
else:
msg = """ For trade {trade}
Response is {resp} """.format(trade=order, resp=json_response)
print_to_console(msg, LOG_ALL_ERRORS)
msg_queue.add_message(DEBUG_INFO_MSG, msg)
log_to_file(msg, file_name)
for order in [trade_pairs.deal_1, trade_pairs.deal_2]:
msg_queue.add_order(ORDERS_MSG, order)
def setUp(self):
set_logging_level(LOG_ALL_ERRORS)
load_key_by_exchange(API_KEY_PATH, EXCHANGE.BITTREX)
self.bittrex_key = get_key_by_exchange(EXCHANGE.BITTREX)
def get_recent_binance_trades(pg_conn, start_time, end_time, force_from_start):
key = get_key_by_exchange(EXCHANGE.BINANCE)
# 2 sequentially query binance
limit = 200
binance_trades_by_pair = {}
for pair_name in BINANCE_CURRENCY_PAIRS:
trades_by_pair = []
pair_id = get_currency_pair_from_binance(pair_name)
last_order_id = 0
if not force_from_start:
# 1 get the most recent trade_id from db for that date
last_trade = get_last_binance_trade(pg_conn,
start_time,
end_time,
pair_id,
table_name="arbitrage_trades")
if last_trade is not None:
last_order_id = last_trade.trade_id
print "last_order_id: for pair_id", last_order_id, pair_id
while True:
recent_trades = receive_binance_trade_batch(
key, pair_name, limit, last_order_id)
if not recent_trades:
break
# Biggest = Latest - will be first
recent_trades.sort(key=lambda x: long(x.trade_id), reverse=True)
for entry in recent_trades:
if start_time <= entry.create_time <= end_time:
trades_by_pair.append(entry)
if len(recent_trades) < limit:
break
if end_time >= recent_trades[0].create_time:
prev_order_id = last_order_id
last_order_id = recent_trades[0].trade_id
if prev_order_id != 0 and prev_order_id == last_order_id:
recent_trades.sort(key=lambda x: long(x.trade_id),
reverse=False)
print "Max", recent_trades[-1:][0].trade_id
print "Min", recent_trades[:-1][0].trade_id
print "Last order"
print recent_trades[:-1][0]
print len(trades_by_pair)
assert False
else:
break
binance_trades_by_pair[pair_id] = trades_by_pair
return binance_trades_by_pair
def setUp(self):
set_logging_level(LOG_ALL_ERRORS)
load_key_by_exchange(API_KEY_PATH, EXCHANGE.POLONIEX)
self.poloniex_key = get_key_by_exchange(EXCHANGE.POLONIEX)
def setUp(self):
set_logging_level(LOG_ALL_ERRORS)
load_key_by_exchange(API_KEY_PATH, EXCHANGE.BINANCE)
self.binance_key = get_key_by_exchange(EXCHANGE.BINANCE)
def setUp(self):
set_logging_level(LOG_ALL_ERRORS)
load_key_by_exchange(API_KEY_PATH, EXCHANGE.HUOBI)
self.huobi_key = get_key_by_exchange(EXCHANGE.HUOBI)
def setUp(self):
set_logging_level(LOG_ALL_ERRORS)
load_key_by_exchange(API_KEY_PATH, EXCHANGE.KRAKEN)
self.kraken_key = get_key_by_exchange(EXCHANGE.KRAKEN)