def get_candles_daily(self, market, exchange):
client = self.clients[exchange]
if exchange == exc.CRYPTOPIA:
d = self.market_id_map(exchange)
pairid = d[market]
candles, v = client.candle_request(pairid)
return models.conv_candle([candles, v], exchange)
elif exchange == exc.BITTREX:
market = models.conv_markets_to(market, exchange)
#hack second client for candles
r = self.clients[rex_API_v2].get_candles(market, "day")
r = r['result']
candles = models.conv_candle(r, exchange)
return candles
elif exchange == exc.KUCOIN:
market = models.conv_markets_to(market, exchange)
klines = client.get_historical_klines_tv(market,
client.RESOLUTION_1DAY,
'1 month ago UTC')
return models.conv_candle(klines, exchange)
elif exchange == exc.HITBTC:
market = models.conv_markets_to(market, exchange)
candles = client.get_candles_daily(market)
candles = models.conv_candle(candles, exchange)
return candles
elif exchange == exc.BINANCE:
market = models.conv_markets_to(market, exchange)
klines = client.get_candles_daily(market)
return models.conv_candle(klines, exchange)
def sync_tx(self, market, exchange):
try:
smarket = models.conv_markets_to(market, exchange)
txs = self.afacade.market_history(smarket,exchange)
n = exc.NAMES[exchange]
smarket = models.conv_markets_to(market, exchange)
dt = datetime.datetime.utcnow()
x = {'market': market, 'exchange': n, 'tx':txs,'timestamp':dt}
self.db.txs.remove({'market':market,'exchange':n})
self.db.txs.insert(x)
self.db.txs_history.insert(x)
except:
self.logger.error("symbol not supported")
def open_orders_symbol(self, symbol, exchange=None):
oo = None
symbol = models.conv_markets_to(symbol, exchange)
if exchange == exc.CRYPTOPIA:
oo, _ = self.clients[exc.CRYPTOPIA].get_openorders_all()
elif exchange == exc.BITTREX:
oo = self.clients[exc.BITTREX].get_open_orders()["result"]
f = lambda x: models.conv_openorder(x, exchange)
oo = list(map(f, oo))
elif exchange == exc.KUCOIN:
oo = self.clients[exc.KUCOIN].get_active_orders(symbol,
kv_format=True)
if len(oo) > 0:
b = oo['BUY']
a = oo['SELL']
l = list()
for x in b:
l.append(models.conv_openorder(x, exchange))
for x in a:
l.append(models.conv_openorder(x, exchange))
oo = l
else:
oo = []
n = exc.NAMES[exchange]
#self.logger.info("open orders: " + str(n) + " " + str(oo))
return oo
def get_market_summaries_only(self, exchange=None):
client = self.clients[exchange]
if exchange == exc.CRYPTOPIA:
r = client.get_markets()[0]
f = lambda x: models.conv_markets_to(x, exchange)
cc_markets = [f(x['Label']) for x in r]
#TODO use object
return cc_markets
elif exchange == exc.BITTREX:
r = client.get_market_summaries()['result']
f = lambda x: models.conv_markets_to(x, exchange)
rex_markets = [x['MarketName'] for x in r]
rex_markets = [f(x) for x in rex_markets]
#rex_markets = [Market(x,exc.BITTREX) for x in rex_markets]
return rex_markets
def get_candles_hourly(self, market, exchange):
client = self.clients[exchange]
if exchange == exc.CRYPTOPIA:
pass
elif exchange==exc.BITTREX:
market = models.conv_markets_to(market, exchange)
r = self.clients[rex_API_v2].get_candles(market,"hour")
r = r['result']
candles = models.conv_candle(r, exchange)
return candles
elif exchange==exc.KUCOIN:
market = models.conv_markets_to(market, exchange)
klines = client.get_historical_klines_tv(market, client.RESOLUTION_1HOUR, '1 week ago UTC')
return models.conv_candle(klines,exchange)
elif exchange==exc.BINANCE:
market = models.conv_markets_to(market, exchange)
klines = client.get_candles_hourly(market)
return models.conv_candle(klines,exchange)
def cancel(self, order):
""" cancel by order """
#if exchange is None: exchange=self.s_exchange
eexchange = order['exchange']
#exchange = exc.get_id(e)
result = None
oid = order['oid']
market = order['market']
otype = order['otype']
#self.logger.info("cancel " + str(order))
self.logger.info("cancel " + str(oid) + " " + str(e) + " " +
str(otype) + " " + str(market))
client = self.clients[exchange]
if exchange == exc.CRYPTOPIA:
result, err = client.cancel_trade_id(oid)
elif exchange == exc.BITTREX:
result = client.cancel(oid)
self.logger.info("bitrex " + str(result))
elif exchange == exc.KUCOIN:
symbol = models.conv_markets_to(market, exchange)
if otype == 'bid':
f = "BUY"
else:
f = "SELL"
self.logger.info("cancel ", symbol, oid, f)
result = client.cancel_order(oid, f, symbol)
self.canceled_orders += 1
return result
elif exchange == exc.HITBTC:
result = client.cancel_order(oid)
self.canceled_orders += 1
elif exchange == exc.BINANCE:
self.logger.error("not implemented. cancel by id")
elif exchange == exc.BITMEX:
result = client.cancel_order(oid)
self.logger.debug("result " + str(result))
return result
def get_candles_minute15(self, market, exchange):
client = self.clients[exchange]
market = models.conv_markets_to(market, exchange)
self.logger.debug("get_candles_minute15 %s %s" % (market, exchange))
if exchange == exc.CRYPTOPIA:
pass
elif exchange == exc.BITTREX:
pass
elif exchange == exc.KUCOIN:
pass
elif exchange == exc.BINANCE:
klines = client.get_candles_minute15(market)
candles = models.conv_candle(klines, exchange)
return candles
def open_orders_symbol(self, symbol, exchange=None):
oo = None
symbol = models.conv_markets_to(symbol, exchange)
if exchange == exc.CRYPTOPIA:
oo, _ = self.clients[exc.CRYPTOPIA].get_openorders_all()
elif exchange == exc.BITTREX:
oo = self.clients[exc.BITTREX].get_open_orders()["result"]
f = lambda x: models.conv_openorder(x, exchange)
oo = list(map(f, oo))
elif exchange == exc.KUCOIN:
oo = self.clients[exc.KUCOIN].get_active_orders(symbol,
kv_format=True)
if len(oo) > 0:
b = oo['BUY']
a = oo['SELL']
l = list()
for x in b:
l.append(models.conv_openorder(x, exchange))
for x in a:
l.append(models.conv_openorder(x, exchange))
oo = l
else:
oo = []
elif exchange == exc.BITMEX:
#TODO
try:
#symbol = "XBTUSD"
oo = client.open_orders(symbol=symbol)
self.logger.debug("open orders %s" % str(oo))
except Exception as e:
self.logger.error("bitmex error %s" % str(e))
elif exchange == exc.DERIBIT:
oo = client.getopenorders(symbol)
n = exc.NAMES[exchange]
#self.logger.info("open orders: " + str(n) + " " + str(oo))
return oo
def sync_job(self):
""" run worker """
db = self.broker.get_db()
col = db.orderbooks #['bitmex_orderbook']
#i = 0
self.logger.debug('sync in the background')
#while True:
market = m.market_from("XBT", "USD")
smarket = models.conv_markets_to(market, exc.BITMEX)
self.broker.sync_orderbook(smarket, exc.BITMEX)
self.broker.sync_trades(smarket, exc.BITMEX)
#col.insert_one(book)
#logger.debug("sync.. %s"%str(book))
#print (book)
#time.sleep(5)
#i+=1
"""
def get_candles_minute(self, market, exchange):
client = self.clients[exchange]
market = models.conv_markets_to(market, exchange)
self.logger.debug("get_candles_minute %s %s"%(market, exchange))
if exchange == exc.CRYPTOPIA:
pass
elif exchange==exc.BITTREX:
r = self.clients[rex_API_v2].get_candles(market,"oneMin")
r = r['result']
candles = models.conv_candle(r, exchange)
return candles
elif exchange==exc.KUCOIN:
klines = client.get_historical_klines_tv(market, client.RESOLUTION_1MINUTE, '1 day ago UTC')
return models.conv_candle(klines,exchange)
elif exchange==exc.BINANCE:
klines = client.get_candles_minute(market)
candles = models.conv_candle(klines,exchange)
return candles
def get_market_summary(self, market, exchange):
client = self.clients[exchange]
market = models.conv_markets_to(market, exchange)
if exchange == exc.CRYPTOPIA:
r, err = client.get_market(market)
r = models.conv_summary(r, exchange)
return r
elif exchange == exc.BITTREX:
r = client.get_market_summary(market)["result"][0]
r = models.conv_summary(r, exchange)
return r
elif exchange == exc.KUCOIN:
r = client.get_tick(market)
c = models.conv_summary(r, exchange)
return c
elif exchange == exc.HITBTC:
r = client.get_ticker(market)
r = models.conv_summary(r, exchange)
return r
elif exchange == exc.BINANCE:
r = client.get_orderbook_ticker_symbol(market)
r = models.conv_summary(r, exchange)
return r
def get_book():
market = m.market_from("XBT", "USD")
smarket = m.conv_markets_to(market, exc.BITMEX)
book = abroker.afacade.get_orderbook(smarket, exc.BITMEX)
return book
def show_book_exc(exchange, market):
global a
smarket = model.conv_markets_to(market, exchange)
book = abroker.afacade.get_orderbook(smarket, exchange)
name = exc.NAMES[exchange]
display_book(book, name)
"""
show orderbooks for all exchanges
"""
import archon.facade as facade
import archon.broker as broker
import archon.exchange.exchanges as exc
import archon.model.models as model
from archon.util import *
import time
import datetime
import math
abroker = broker.Broker(setAuto=False)
abroker.set_keys_exchange_file(exchanges=[exc.KRAKEN])
client = abroker.afacade.get_client(exc.KRAKEN)
market = model.market_from("BTC", "USD")
smarket = model.conv_markets_to(market, exc.KRAKEN)
t = client.get_trades(smarket)
for x in t:
print(x)
def submit_order(self, order, exchange=None):
""" submit order which is array [type,order,qty] """
# ("order " + str(order))
self.logger.info("submit order " + str(exchange) + " " + str(order))
market, ttype, order_price, qty = order
market = models.conv_markets_to(market, exchange)
client = self.clients[exchange]
orderD = {
"market": market,
"type": ttype,
"price": order_price,
"quantity": qty,
"status": ORDERSTATUS_SUBMITTED
}
order_success = False
#order[ORDERSTATUS] = ORDERSTATUS_SUBMITTED
self.orders.append(orderD)
if exchange == exc.CRYPTOPIA:
order_result, err = self.clients[exc.CRYPTOPIA].submit_trade(
market, ttype, order_price, qty)
if err:
self.logger.error("! error with order " + str(order) + " " +
str(err))
else:
order_success = True
elif exchange == exc.BITTREX:
if ttype == ORDER_SIDE_BUY:
order_result = self.clients[exc.BITTREX].buy_limit(
market, qty, order_price)
#TODO check status
order_success = True
elif ttype == ORDER_SIDE_SELL:
order_result = self.clients[exc.BITTREX].sell_limit(
market, qty, order_price)
#TODO check status
order_success = True
elif exchange == exc.KUCOIN:
c = self.clients[exc.KUCOIN]
if ttype == ORDER_SIDE_BUY:
order_result = c.create_buy_order(market, order_price, qty)
order_success = True
elif ttype == ORDER_SIDE_SELL:
order_result = c.create_sell_order(market, order_price, qty)
order_success = True
elif exchange == exc.HITBTC:
ra = int(random.random() * 10000)
oid = str(12341235 + ra)
#self.logger.info("submit %s %s"%(str(oid),str(market)))
self.logger.info("submit " + str(oid) + " " + str(market))
if ttype == ORDER_SIDE_BUY:
ttype = "buy"
else:
ttype = "sell"
order_result = client.submit_order(oid, market, ttype, qty,
order_price)
order_success = True
elif exchange == exc.BINANCE:
self.logger.info("submit %s" % order)
if ttype == ORDER_SIDE_BUY:
try:
order_result = client.submit_order_buy(
market, qty, order_price)
self.logger.info("order result: %s" % str(order_result))
order_success = False
#{'symbol': 'MDABTC', 'orderId': 34475311, 'clientOrderId': 'zecKIFc7bLHY6W1oAqwAXi',
# 'transactTime': 1545021630023,
# 'price': '0.00024200', 'origQty': '209.00000000',
# 'executedQty': '209.00000000', 'cummulativeQuoteQty': '0.05016209',
# 'status': 'FILLED', 'timeInForce': 'GTC',
# 'type': 'LIMIT', 'side': 'BUY', 'fills':
if order_result['status'] == 'FILLED':
order_success = True
orderD[ORDERSTATUS] = ORDERSTATUS_FILLED
except Exception as err:
orderD[ORDERSTATUS] = ORDERSTATUS_REJECTED
else:
try:
order_result = client.submit_order_sell(
market, qty, order_price)
self.logger.info("order result: %s" % str(order_result))
order_success = False
if order_result['status'] == 'FILLED':
order_success = True
orderD[ORDERSTATUS] = ORDERSTATUS_FILLED
except Exception as err:
orderD[ORDERSTATUS] = ORDERSTATUS_REJECTED
elif exchange == exc.BITMEX:
if ttype == ORDER_SIDE_BUY:
order_result = client.buy(quantity=qty,
price=order_price,
symbol=market)
elif ttype == ORDER_SIDE_SELL:
order_result = client.sell(quantity=qty,
price=order_price,
symbol=market)
if order_success:
self.submitted_orders += 1
#TODO log submitted order separately
self.logger.info("order result: %s" % str(order_result))
return [order_result, order_success]
