def run(self):
# Retrieve password
#self.SKYPE_PWD = getpass.getpass()
# Kucoin connection
client = Client(self.API_KEY, self.SECRET_KEY)
# Skype connection
#skyper = Skyper(self.SKYPE_USERNAME, self.SKYPE_PWD, self.SKYPE_USERS)
send_msg_skype(self.skyper, "KUCOIN", time.ctime(int(time.time())),
"Bot is running...")
self.fileManagementObt.log("KUCOIN", time.ctime(int(time.time())),
"Bot is running...")
# Telegram connection
#telegramer = Telegramer(token='521036992:AAG8pG_Gc7tmldnlpJgXGUwrPkGGKjhtCHw')
self.telegramer.send_message(self.TELEGRAM_CHAT_ID, "KUCOIN",
time.ctime(int(time.time())),
"BOT is running...")
# Get list of symbols
try:
if self.DEBUG:
previousInfo = [{
u'sell': 10824.0,
u'sort': 100,
u'buy': 10820.0,
u'changeRate': 0.0417,
u'vol': 208.75995661,
u'symbol': u'BTC-USDT',
u'high': 10849.999999,
u'coinType': u'BTC',
u'lastDealPrice': 10824.0,
u'feeRate': 0.001,
u'volValue': 2189548.32186627,
u'trading': True,
u'low': 9999.0,
u'coinTypePair': u'USDT',
u'datetime': 1519026140000L,
u'change': 433.779732
}, {
u'sell': 0.087433,
u'sort': 100,
u'buy': 0.08713844,
u'changeRate': -0.0054,
u'vol': 3946.72613,
u'symbol': u'ETH-BTC',
u'high': 0.089597,
u'coinType': u'LTC',
u'lastDealPrice': 0.08712844,
u'feeRate': 0.001,
u'volValue': 347.13935351,
u'trading': True,
u'low': 0.086022,
u'coinTypePair': u'BTC',
u'datetime': 1519026138000L,
u'change': -0.00047156
}]
else:
previousInfo = client.get_trading_symbols()
if previousInfo:
for symbol in previousInfo:
if symbol['coinType'] not in self.symbols_list:
self.symbols_list.append(symbol['coinType'])
except:
exc_type, exc_obj, exc_tb = sys.exc_info()
fname = os.path.split(exc_tb.tb_frame.f_code.co_filename)[1]
print(exc_type, fname, exc_tb.tb_lineno)
strFormatted = "{}\n{}:\n{}\n".format(exc_type, fname,
exc_tb.tb_lineno)
self.fileManagementObt.log("KUCOIN", time.ctime(int(time.time())),
strFormatted)
# Request in a loop the list of symbols, and compare it with the initial list.
while True:
try:
currentTime = time.ctime(int(time.time()))
if self.DEBUG:
info = [{
u'sell': 10824.0,
u'sort': 100,
u'buy': 10820.0,
u'changeRate': 0.0417,
u'vol': 208.75995661,
u'symbol': u'BTC-USDT',
u'high': 10849.999999,
u'coinType': u'BTC',
u'lastDealPrice': 10824.0,
u'feeRate': 0.001,
u'volValue': 2189548.32186627,
u'trading': True,
u'low': 9999.0,
u'coinTypePair': u'USDT',
u'datetime': 1519026140000L,
u'change': 433.779732
}, {
u'sell': 0.087433,
u'sort': 100,
u'buy': 0.08713844,
u'changeRate': -0.0054,
u'vol': 3946.72613,
u'symbol': u'ETH-BTC',
u'high': 0.089597,
u'coinType': u'LTC',
u'lastDealPrice': 0.08712844,
u'feeRate': 0.001,
u'volValue': 347.13935351,
u'trading': True,
u'low': 0.086022,
u'coinTypePair': u'BTC',
u'datetime': 1519026138000L,
u'change': -0.00047156
}, {
u'sell': 944.5969,
u'sort': 100,
u'buy': 942.9,
u'changeRate': 0.0291,
u'vol': 1116.388536,
u'symbol': u'ETH-USDT',
u'high': 947.777777,
u'coinType': u'ETH',
u'lastDealPrice': 942.9,
u'feeRate': 0.001,
u'volValue': 1031605.24945772,
u'trading': True,
u'low': 892.137139,
u'coinTypePair': u'USDT',
u'datetime': 1519026140000L,
u'change': 26.661531
}]
else:
info = client.get_trading_symbols()
if info:
print "( ", currentTime, " ): [ KUCOIN ] get_trading_symbols"
# Looking for any new symbols.
if self.CHECK_NEW_SYMBOLS == True:
for symbol in info:
if symbol['coinType'] not in self.symbols_list:
# New symbol detected.
self.symbols_list.append(symbol['coinType'])
depositAddress = {}
print "( ", currentTime, " ): [ KUCOIN ] new symbol named ", symbol[
'coinType']
print "( ", currentTime, " ): [ KUCOIN ] get_deposit_address"
try:
depositAddress = client.get_deposit_address(
symbol['coinType'])
except:
pass
# Send a message to the skype user and telegram channel.
if len(depositAddress) != 0:
self.telegramer.send_message(
self.TELEGRAM_CHAT_ID, "KUCOIN",
currentTime, depositAddress)
send_msg_skype(self.skyper, "KUCOIN",
currentTime, depositAddress)
print "( ", currentTime, " ): [ KUCOIN ] depositAddress ", depositAddress
else:
self.telegramer.send_message(
self.TELEGRAM_CHAT_ID, "KUCOIN",
currentTime, symbol['coinType'])
send_msg_skype(self.skyper, "KUCOIN",
currentTime,
symbol['coinType'])
print "( ", currentTime, " ): [ KUCOIN ] depositAddress ", symbol[
'coinType']
self.fileManagementObt.log(
"KUCOIN", time.ctime(int(time.time())),
depositAddress)
break
# Looking for a symbol in the list.
for symbol in self.SYMBOLS:
depositAddress = {}
for kucoinSymbol in info:
if kucoinSymbol['coinType'] == symbol:
# Symbol in the list detected.
print "( ", currentTime, " ): [ KUCOIN ] found symbol ", symbol
print "( ", currentTime, " ): [ KUCOIN ] get_deposit_address"
if self.ALARM == True:
if self.alarm_function_running == False:
self.alarmThread = Thread(
target=self.threaded_alarm_function
)
self.alarmThread.start()
self.alarm_function_running = True
try:
depositAddress = client.get_deposit_address(
symbol)
except:
pass
if len(depositAddress) != 0:
self.telegramer.send_message(
self.TELEGRAM_CHAT_ID, "KUCOIN",
currentTime, depositAddress)
send_msg_skype(self.skyper, "KUCOIN",
currentTime, depositAddress)
print "( ", currentTime, " ): [ KUCOIN ] depositAddress ", depositAddress
else:
self.telegramer.send_message(
self.TELEGRAM_CHAT_ID, "KUCOIN",
currentTime, symbol)
send_msg_skype(self.skyper, "KUCOIN",
currentTime, symbol)
print "( ", currentTime, " ): [ KUCOIN ] depositAddress ", symbol
self.SYMBOLS.remove(symbol)
self.fileManagementObt.log(
"KUCOIN", time.ctime(int(time.time())),
depositAddress)
break
previousInfo = info
except:
exc_type, exc_obj, exc_tb = sys.exc_info()
fname = os.path.split(exc_tb.tb_frame.f_code.co_filename)[1]
print(exc_type, fname, exc_tb.tb_lineno)
strFormatted = "{}\n{}:\n{}\n".format(exc_type, fname,
exc_tb.tb_lineno)
self.fileManagementObt.log("KUCOIN",
time.ctime(int(time.time())),
strFormatted)
time.sleep(10)
class KucoinWrapper(BaseExchangeWrapper):
INTERVAL_MAP = {
CandleTicks.one_minute : Client.RESOLUTION_1MINUTE,
CandleTicks.five_minutes : Client.RESOLUTION_5MINUTES,
CandleTicks.thirty_minutes : Client.RESOLUTION_30MINUTES,
CandleTicks.one_hour : Client.RESOLUTION_1HOUR,
CandleTicks.one_day : Client.RESOLUTION_1DAY,
}
TIME_SINCE_MAP = {
CandleTicks.one_minute : "1 hour ago",
CandleTicks.five_minutes : "5 hours ago",
CandleTicks.thirty_minutes : "26 hours ago",
CandleTicks.one_hour : "52 hours ago",
CandleTicks.one_day : "60 days ago",
}
ORDER_TYPE_MAPPINGS = {
'BUY' : OrderType.limit_buy,
'SELL' : OrderType.limit_sell,
}
def __init__(self, api_key, api_secret):
BaseExchangeWrapper.__init__(self)
self._handle = Client(api_key, api_secret)
self._filters = {}
self._load_markets()
def _perform_request(self, request_lambda):
try:
return request_lambda()
except KucoinAPIException as ex:
raise ExchangeAPIException('Failed to perform request: {0}'.format(ex.message))
def _load_currencies(self):
result = self._perform_request(lambda: self._handle.get_coin_list())
for coin in result:
self.add_currency(
Currency(
coin['coin'],
coin['name'],
coin['confirmationCount'],
coin['withdrawFeeRate'] # check if this is right
)
)
def _load_markets(self):
self._load_currencies()
result = self._perform_request(lambda: self._handle.get_trading_symbols())
for market in result:
self.add_market(market['coinTypePair'], market['coinType'])
def _make_symbol(self, base_currency_code, market_currency_code):
return '{0}-{1}'.format(market_currency_code, base_currency_code)
def _process_paged_request(self, make_request, callback):
page = 1
limit = 50
data = self._perform_request(lambda: make_request(limit=limit, page=page))
while len(data['datas']) > 0:
for entry in data['datas']:
callback(entry)
page += 1
data = make_request(limit=limit, page=page)
def get_market_state(self, base_currency_code, market_currency_code):
symbol = self._make_symbol(base_currency_code, market_currency_code)
data = self._perform_request(lambda: self._handle.get_tick(symbol))
return MarketState(data['sell'], data['buy'], data['lastDealPrice'])
def get_orderbook(self, base_currency_code, market_currency_code):
symbol = self._make_symbol(base_currency_code, market_currency_code)
data = self._perform_request(lambda: self._handle.get_order_book(symbol))
buy_orderbook = Orderbook()
sell_orderbook = Orderbook()
for item in data['BUY']:
buy_orderbook.add_order(Order(item[0], item[1]))
for item in data['SELL']:
sell_orderbook.add_order(Order(item[0], item[1]))
return (buy_orderbook, sell_orderbook)
def get_candles(self, base_currency_code, market_currency_code, interval, limit):
symbol = self._make_symbol(base_currency_code, market_currency_code)
since = KucoinWrapper.TIME_SINCE_MAP[interval]
kucoin_interval = KucoinWrapper.INTERVAL_MAP[interval]
data = self._perform_request(
lambda: self._handle.get_historical_klines_tv(symbol, kucoin_interval, since)
)
output = []
for i in data:
output.append(Candle(
i[3], # Low
i[2], # High
i[1], # Open
i[4], # Close
dateparser.parse(str(i[0]))
))
return output
def get_wallets(self):
output = []
self._process_paged_request(
self._handle.get_all_balances,
lambda entry: output.append(Wallet(
entry['coinType'],
entry['balance'],
entry['balance'] - entry['freezeBalance'],
entry['freezeBalance']
))
)
return output
def get_wallet(self, currency_code):
self.check_valid_currency(currency_code)
data = self._perform_request(lambda: self._handle.get_coin_balance(currency_code))
return Wallet(
self._currencies[currency_code],
data['balance'],
data['balance'] - data['freezeBalance'],
data['freezeBalance']
)
def get_deposit_history(self, currency_code):
request = lambda limit, page: self._handle.get_deposits(
currency_code,
limit=limit,
page=page
)
output = []
self._process_paged_request(
request,
lambda entry: output.append(Transfer(
self._currencies[entry['coinType']],
entry['amount'],
entry['outerWalletTxid'], # is this right?
1 if entry['status'] == 'FINISHED' else 0,
0, # cost
entry['status'] == 'CANCEL',
dataparser.parse(str(entry['createdAt']))
))
)
return output
def get_withdrawal_history(self, currency_code):
request = lambda limit, page: self._handle.get_withdrawals(
currency_code,
limit=limit,
page=page
)
output = []
self._process_paged_request(
request,
lambda entry: output.append(Transfer(
self._currencies[entry['coinType']],
entry['amount'],
entry['outerWalletTxid'], # is this right?
0,
entry['fee'],
entry['status'] == 'CANCEL',
dataparser.parse(str(entry['createdAt']))
))
)
return output
def get_open_orders(self):
raise ExchangeAPIException('Not implemented')
def get_order_history(self):
output = []
self._process_paged_request(
self._handle.get_dealt_orders,
lambda entry: output.append(TradeOrder(
data['orderOid'],
self._currencies[base_currency],
self._currencies[market_currency],
None, # Date open
dateparser.parse(str(data['createdAt'])),
data['amount'],
0, # Amount remaining
data['dealPrice'],
data['dealPrice'],
KucoinWrapper.ORDER_TYPE_MAPPINGS[data['direction']]
))
)
return output
def buy(self, base_currency_code, market_currency_code, amount, rate):
symbol = self._make_symbol(base_currency_code, market_currency_code)
result = self._perform_request(lambda: self._handle.create_buy_order(symbol, rate, amount))
return result['orderOid']
def sell(self, base_currency_code, market_currency_code, amount, rate):
symbol = self._make_symbol(base_currency_code, market_currency_code)
result = self._perform_request(lambda: self._handle.create_sell_order(symbol, rate, amount))
return result['orderOid']
def cancel_order(self, base_currency_code, market_currency_code, order_id):
self._perform_request(lambda: self._handle.cancel_order(order_id, None))
def withdraw(self, currency_code, amount, address, address_tag):
if address_tag:
raise ExchangeAPIException('Address tag not supported')
self._perform_request(
lambda: self._handle.create_withdrawal(currency_code, amount, address)
)
def get_deposit_address(self, currency_code):
result = self._perform_request(lambda: self._handle.get_deposit_address(currency_code))
return CryptoAddress(
currency_code,
result['address'],
None
)
def transfers_needs_asset(self):
return True
