class KuCoin:
lastTimestamp = None
def __init__(self, Config):
self.publicKey = Config.getPublicKey()
self.secretKey = Config.getSecretKey()
self.client = Client(self.publicKey, self.secretKey)
def checkKeys(self):
try:
b = self.client.get_api_keys()
if 'code' not in b: # If code is there, it means an error code so wrong.
return True
#else:
# self.errorMessage(b)
# return False
except (Exception): #TO DO: extract kucoin exception message directly
self.errorMessage("KuCoin API error.")
return False
def getBalance(self, limit=None, page=None):
try:
jsonD = self.client.get_all_balances()
except Exception as e:
print("Error getting balance.")
return
balances = []
for x in jsonD:
if x['balance'] != 0.0:
balances.append(x) #TO DO, MAKE IT SAME NAMES AS HITBTC
for b in balances:
for key in b.keys():
if (key == "coinType"):
newKey = key.replace("coinType", "currency")
b[newKey] = b[key]
del b[key]
if (key == "balanceStr"):
newKey = key.replace("balanceStr", "available")
b[newKey] = b[key]
del b[key]
return balances
def getSymbols(self):
jsonD = self.client.get_trading_symbols()
symbols = []
for x in jsonD:
symbols.append(x['symbol'])
return symbols
def getOrderHistory(self, Config):
try:
orders = self.client.get_dealt_orders(symbol=Config.getCurrency())
return orders
except Exception as e:
print("ERROR GETTING ORDER HISTORY:")
print(e)
return None
def getActiveOrders(self, Config):
try:
orders = self.client.get_active_orders(symbol=Config.getCurrency())
return orders
except Exception as e:
print("ERROR GETTING ACTIVE ORDERS")
print(e)
return None
def getOrderBook(self, Config, request):
try:
orders = self.client.get_order_book(Config.getCurrency())
if (request == 'SELL'):
return orders['SELL']
if (request == 'BUY'):
return orders['BUY']
except Exception as e:
print(e)
return None
def cancelBuyOrders(self, Config):
try:
cancelAttempt = self.client.cancel_all_orders(
Config.getCurrency(), 'BUY')
if cancelAttempt is None:
return True
except Exception as e:
print(e)
return False
def cancelSellOrders(self, Config):
try:
cancelAttempt = self.client.cancel_all_orders(
Config.getCurrency(), 'SELL')
if cancelAttempt is None:
return True
except Exception as e:
print(e)
return False
def cancelOrders(self, Config):
try:
cancelAttempt = self.client.cancel_all_orders(
Config.getCurrency(), 'BUY')
cancelAttempt = self.client.cancel_all_orders(
Config.getCurrency(), 'SELL')
if cancelAttempt is None:
return True
except Exception as e:
print(e)
return False
def createOrder(self, symbol, side, price, amount):
try:
#sellPrice = str(round(float(price), 6))
transaction = self.client.create_order(symbol, side.upper(), price,
amount)
return transaction # returns orderOid
except Exception as e:
print("Took too long.. mismatch I think??")
print(e)
def errorMessage(self, b):
print(
'\n =================== CyrCraft - Errrr Errorrrrrr ======================= \n'
)
print(b)
print(
'Keys are wrong..\nType 1 to set your keys.. or else any key to go Configuration Menu..'
)
print(
'\n ======================================================================= \n'
)
class KucoinApi(PyexAPI):
"""kucoin API interface.
"""
logger = logging.getLogger()
def __init__(self,
api_server: str,
api_key: str,
secret_key: str,
timeout: float,
requests_params=None):
assert (isinstance(api_server, str))
assert (isinstance(api_key, str))
assert (isinstance(secret_key, str))
assert (isinstance(timeout, float))
self.api_server = api_server
self.api_key = api_key
self.secret_key = secret_key
self.timeout = timeout
self.client = Client(api_key, secret_key)
def get_markets(self):
return self.client.get_trading_markets()
def ticker(self, pair: str):
assert (isinstance(pair, str))
return self.client.get_tick(pair)
def get_balances(self):
return self.client.get_all_balances()
def get_fiat_balance(self, fiat: str):
assert (isinstance(fiat, str))
return self.client.get_total_balance(fiat)
def get_balance(self, coin: str):
assert (isinstance(coin, str))
return self.client.get_coin_balance(coin)
def get_coin_info(self, coin: str):
assert (isinstance(coin, str))
return self.client.get_coin_info(coin)
def get_user_info(self):
return self.client.get_user()
def order_book(self, pair: str, limit=None):
assert (isinstance(pair, str))
return self.client.get_order_book(pair, limit)
def get_orders(self, pair: str) -> List[Order]:
assert (isinstance(pair, str))
orders = self.client.get_active_orders(pair)
sell_orders = list(
map(lambda item: Order.from_list(item, pair, True),
orders[self.client.SIDE_SELL]))
buy_orders = list(
map(lambda item: Order.from_list(item, pair, False),
orders[self.client.SIDE_BUY]))
return sell_orders + buy_orders
def place_order(self, pair: str, is_sell: bool, price: Wad,
amount: Wad) -> str:
assert (isinstance(pair, str))
assert (isinstance(is_sell, bool))
assert (isinstance(price, Wad))
assert (isinstance(amount, Wad))
side = self.client.SIDE_SELL if is_sell else self.client.SIDE_BUY
self.logger.info(f"Placing order ({side}, amount {amount} of {pair},"
f" price {price})...")
result = self.client.create_order(pair, side, price, amount)
order_id = result['orderOid']
self.logger.info(f"Placed order as #{order_id}")
return order_id
def cancel_order(self, order_id: str, is_sell: bool, pair: str):
assert (isinstance(order_id, str))
assert (isinstance(is_sell, bool))
assert (isinstance(pair, str))
side = self.client.SIDE_SELL if is_sell else self.client.SIDE_BUY
self.logger.info(f"Cancelling order #{order_id} of type {side}...")
try:
self.client.cancel_order(order_id, side, pair)
self.logger.info(f"Canceled order #{order_id}...")
return True
except Exception as e:
self.logger.error(f"Failed to cancel order #{order_id}... {e}")
return False
def get_trades(self, pair: str, page_number: int = 1) -> List[Trade]:
assert (isinstance(pair, str))
assert (isinstance(page_number, int))
page_number = page_number - 1
limit = 100
result = self.client.get_symbol_dealt_orders(pair, page_number, limit)
return list(
map(lambda item: Trade.from_dict(pair, item), result['datas']))
def get_all_trades(self, pair: str, page_number: int = 1) -> List[Trade]:
assert (isinstance(pair, str))
assert (page_number == 1)
result = self.client.get_recent_orders(pair, 50)
return list(map(lambda item: Trade.from_list(pair, item), result))
minSpread = 0.3 # %age
disp = 0.000001 # amount to undercut or outbid
orderSize = 0.00001 # quoted in first currency in pair
# loop to keep bot running
while True:
# get orderbook to check bid-ask
orderBook = client.get_order_book(pair, limit=1)
bid = orderBook["BUY"][0][0]
ask = orderBook["SELL"][0][0]
spread = calcSpread(bid, ask)
print("SPREAD: " + str(spread) + "%")
if spread > minSpread:
# get our active orders to check quantity and price points
orders = client.get_active_orders(pair)
noBuys = len(orders["BUY"]) == 0
noSells = len(orders["SELL"]) == 0
if noBuys and noSells:
# place orders
print("Placing new set of orders...")
client.create_buy_order(pair, bid + disp, orderSize)
client.create_sell_order(pair, ask - disp, orderSize)
print("Orders placed")
#else:
# if there is a buy order and it is less than the bid, replace it
#if len(orders["BUY"]) > 0 and orders["BUY"][0][2] < bid:
# orderID = orders["BUY"][0][5]
# print("Cancelling buy order...")
1000)
def determine_order_data(data):
try:
logging.info("Found order: " + str(data[0]))
order = True
except:
order = False
return order
cycle = 0
while True:
try:
openOrders = (client.get_active_orders(tokenPair))
sellOrderData = openOrders['SELL']
buyOrderData = openOrders['BUY']
if (openOrders['BUY']) and (openOrders['SELL']):
logging.info(openOrders)
elif ((determine_order_data(sellOrderData) == False) and (determine_order_data(buyOrderData) == True))\
or ((determine_order_data(sellOrderData) == True) and (determine_order_data(buyOrderData) == False)):
for type in openOrders:
try:
oid = get_oid(openOrders[type])
logging.info("Cancel order " + oid)
logging.info(client.cancel_order(tokenPair, oid, type))
except:
logging.info("Order type " + type + " completed")
if token:
post_slack(type)
