def display_order_book(pair): client = Client("", "", "") # get order book stdscr = curses.initscr() curses.curs_set(0) stdscr.addstr(0, 0, str("Pair: " + pair)) stdscr.addstr(5, 0, "------------------------------------------------") stdscr.addstr(6, 0, "Ask Price") stdscr.addstr(6, 14, "Ask Size") stdscr.addstr(6, 27, "Bid Price") stdscr.addstr(6, 40, "Bid Size") while True: try: orderbook = client.get_order_book(pair) depth = min(20, (min(len(orderbook["asks"]), len(orderbook["bids"])))) ask_prices, ask_sizes, bid_prices, bid_sizes = [], [], [], [] mid_price = str((float(orderbook["asks"][0][0]) + float(orderbook["bids"][0][0])) / 2.0) total_ask_volume = 0.0 total_bid_volume = 0.0 spread = float(orderbook["asks"][0][0]) - float(orderbook["bids"][0][0]) stdscr.addstr(2, 0, "Spread: " + str(spread)) for i in range(depth): total_ask_volume += float(orderbook["asks"][i][1]) total_bid_volume += float(orderbook["bids"][i][1]) stdscr.addstr(1, 0, "Mid Price: " + mid_price) stdscr.addstr(i+7, 0, str(orderbook["asks"][i][0])) stdscr.addstr(i+7, 14, str(orderbook["asks"][i][1])) stdscr.addstr(i+7, 27, str(orderbook["bids"][i][0])) stdscr.addstr(i+7, 40, str(orderbook["bids"][i][1])) stdscr.refresh() stdscr.addstr(3, 0, "Ask Volume: " + str(total_ask_volume)) stdscr.addstr(4, 0, "Bid Volume: " + str(total_bid_volume)) stdscr.refresh() time.sleep(2) stdscr.refresh() except KeyboardInterrupt: curses.curs_set(1) curses.endwin() break curses.curs_set(1) curses.endwin()
w2 = avolume / mid_volume return sum([(w1 * aprice), (w2 * bprice)]) client = Client(api_key='5b35631b09e5a168abec621a', api_secret='d564e70a-f45e-49cd-b13c-a31fa5bbbb9d') starttime = datetime.datetime.now( datetime.timezone.utc).strftime("%Y-%m-%dT%H:%M:%S.%f%Z") hist_bestBid, hist_bestAsk, hist_spread, hist_midpoint, hist_volume, hist_midpointVolume, hist_gravity = [], [], [], [], [], [], [] n = 60 while (1): time = datetime.datetime.now( datetime.timezone.utc).strftime("%Y-%m-%dT%H:%M:%S.%f%Z") market_data = client.get_order_book('OMX-BTC', limit=9999) recent_orders = client.get_recent_orders('OMX-BTC', limit=9999) print(recent_orders) break buys, sells = market_data['BUY'], market_data['SELL'] hist_bestBid.append(buys[0][0]) hist_bestAsk.append(sells[0][0]) hist_midpoint.append(np.mean([hist_bestAsk[-1], hist_bestBid[-1]])) hist_spread.append(hist_bestAsk[-1] - hist_bestBid[-1]) hist_volume.append( sum([order[2] for order in buys]) + sum([order[2] for order in sells])) hist_midpointVolume.append(sum([buys[0][2], sells[0][2]])) hist_gravity.append( gravity(buys[0][2], sells[0][2], buys[0][0], sells[0][0])) buy_cnt, sell_cnt = 0, 0 exec_orderVol = []
# continue # # for market in sorted_markets[base]: # if market_data[market]['bid'] <= 0: # del sorted_markets[base] # break # client = ccxt.binance({ # 'apiKey': 'BewB2ElWDT8E6ujjvLFaaWoKHcpdBauHMM8MGdLN5GAmGcSnYB95cMu8ZJB6RYVW', # 'secret': 'eIwUpHArqkyQaKY66Is8L1YrPXNpZFu1LK4mqdt6mWgG1mBwl58CpE6QDtgPl6NT', # 'enableRateLimit': True, # }) # client = ccxt.kucoin({ # 'apiKey': '5b35631b09e5a168abec621a', # 'secret': 'd564e70a-f45e-49cd-b13c-a31fa5bbbb9d' # # }) client = Client(api_key='5b35631b09e5a168abec621a', api_secret='d564e70a-f45e-49cd-b13c-a31fa5bbbb9d') #currencies = client.fetch_markets() #print(currencies) #market_data = client.fetch_ticker("ETH/BTC") #market_data = client.fetch_closed_orders("ETH/BTC") #market_data = client.fetch_balance() market_data = client.get_order_book('KCS-BTC', limit=50) #market_data = client.fetch_orde print(market_data)
print("Kucoin scraper 1.1 aggregating data to ", filename, " and ", filename1) with open(filepath, 'r') as f: data = f.read() if data == "": data = {} else: data = json.loads(data) data1 = {} timeStr = datetime.datetime.now( datetime.timezone.utc).strftime("%Y-%m-%dT%H:%M:%S.%f%Z") orders = client.get_order_book(ticker, limit=999999) #print("Orders:", orders) recent_orders = client.get_recent_orders(ticker, limit=99999) #print("recent orders", recent_orders) #print(recent_orders) data[timeStr] = {"buys": orders['BUY'], "sells": orders['SELL']} data1[timeStr] = np.array(recent_orders) #print(f'DEBUG writing data: {data} \n data1: {data1}') with open(filepath, 'w') as f: f.write(json.dumps(data)) f.close()
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' )
from selenium.webdriver.support import expected_conditions as EC from selenium.common.exceptions import NoSuchElementException from appium.webdriver.common.touch_action import TouchAction from selenium.webdriver.common.action_chains import ActionChains from selenium.webdriver.common.keys import Keys import sys import time from kucoin.client import Client api_key = '5da8173338300c5593ce60cb' api_secret = '1656f653-6d7e-483f-8360-4e9df8d43d2d' api_passphrase = 'qwerasdf1234!' client = Client(api_key, api_secret, api_passphrase) depth = client.get_order_book('ETH-BTC') driver = webdriver.Remote( command_executor='http://127.0.0.1:4723/wd/hub', desired_capabilities={ "platformName": "iOS", "platformVersion": "<iOS 버전>", "deviceName": "<디바이스 이름>", "app": "/Users/xxx/xxx_internal.ipa", "automationName": "XCUITest", "bundleId": "com.ozys.xxx.internal", "udid": "<udid 기입>", "noReset": "true", "appActivity": "com.xxx.SplashActivity", "newCommandTimeout": 7200,
class KucoinApi(PyexAPI): """kucoin API interface. """ logger = logging.getLogger() def __init__(self, api_server: str, api_key: str, secret_key: str, api_passphrase: str, timeout: float, requests_params=None): assert (isinstance(api_server, str)) assert (isinstance(api_key, str)) assert (isinstance(secret_key, str)) assert (isinstance(api_passphrase, 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, api_passphrase) def get_symbols(self): return self.client.get_symbols() def ticker(self, pair: str): assert (isinstance(pair, str)) return self.client.get_ticker(pair) def get_balances(self): return self.client.get_accounts() def get_coin_info(self, coin: str): assert (isinstance(coin, str)) return self.client.get_currency(coin) def order_book(self, pair: str, limit=None): assert (isinstance(pair, str)) return self.client.get_order_book(pair) def get_orders(self, pair: str) -> List[Order]: assert (isinstance(pair, str)) orders = self.client.get_orders(pair, 'active') return list( map(lambda item: Order.to_order(item, pair), orders['items'])) 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_limit_order(pair, side, str(price), str(amount)) order_id = result['orderId'] 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) 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_fills(symbol=pair, page=page_number, page_size=limit) return list( map(lambda item: Trade.from_dict(pair, item), result['items'])) 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_trade_histories(pair) return list(map(lambda item: Trade.from_list(pair, item), result))
def calcSpread( bid, ask): return ((ask - bid) / bid) * 100 # "sign-in" client = Client('key1', 'key2') # set runtime vars manually pair = "ETH-BTC" 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)
try: while len( client.get_active_orders(symbol)['SELL'] > 0 and client.get_active_orders(symbol)['BUY']) > 0: print 'Waiting for order to fill...' print 'Filled' except: wait_until_filled(symbol) # Dumb loop to keep running while True: # Pull order book data print 'Pulling data...' try: eth_btc_orders = client.get_order_book('ETH-BTC', limit=1) rpx_eth_orders = client.get_order_book('RPX-ETH', limit=1) rpx_btc_orders = client.get_order_book('RPX-BTC', limit=1) except: eth_btc_orders = client.get_order_book('ETH-BTC', limit=1) rpx_eth_orders = client.get_order_book('RPX-ETH', limit=1) rpx_btc_orders = client.get_order_book('RPX-BTC', limit=1) eth_btc_bid = eth_btc_orders['BUY'][0][0] eth_btc_ask = eth_btc_orders['SELL'][0][0] rpx_eth_bid = rpx_eth_orders['BUY'][0][0] rpx_eth_ask = rpx_eth_orders['SELL'][0][0] rpx_btc_bid = rpx_btc_orders['BUY'][0][0] rpx_btc_ask = rpx_btc_orders['SELL'][0][0]
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
class KucoinClient(AbstractClient): def __init__(self, listener): self.exchange = 'kucoin' self.trade_fee = Decimal(0.001) self.client = Client(api_keys.kucoin[0], api_keys.kucoin[1]) super(KucoinClient, self).__init__(listener) self.get_all_balances() def _buy(self, symbol, price, amount): result = self.client.create_buy_order(symbol, price, amount) self.open_orders[symbol] = [str(result['orderOid']), 'BUY', symbol] def _sell(self, symbol, price, amount): result = self.client.create_sell_order(symbol, price, amount) self.open_orders[symbol] = [str(result['orderOid']), 'SELL', symbol] def _cancel(self, symbol): order = self.open_orders.pop(symbol) self.client.cancel_order(order[0], order[1], symbol=order[2]) time.sleep(1) if not self.is_order_fulfilled(order[0]): raise Exception("cancelled order not fulfilled!") def is_order_fulfilled(self, orderOid): try: for data in self.client.get_dealt_orders()['datas']: if data['orderOid'] == orderOid: return True except (KucoinRequestException, KucoinAPIException) as e: print datetime.now(), "[Kucoin] is order fulfilled error", str( e).replace('\r\n', '') self.errors += 1 return False def get_all_balances(self): # Kucoin paginates the coin balances and we can only retrieve 20 coins per page page = 1 while True: try: result = self.client.get_all_balances_paged(limit=20, page=page) for balance in result['datas']: self.coin_balances[str(balance['coinType'])] = Decimal( str(balance['balance']) ) # + Decimal(balance['freezeBalance']) page = result['currPageNo'] + 1 if page > result['pageNos']: break except (KucoinRequestException, KucoinAPIException) as e: print datetime.now(), "[Kucoin] get all balances error:", str( e).replace('\r\n', '') self.errors += 1 break return self.coin_balances # Gets the buy/sell price and amount for one symbol at a time (inefficient). def _market_poll(self): result = {'success': False} result['client'] = self result['timestamp'] = int(time.time() * 1000) result['coinpairs'] = {} threads = [] for symbol in self.exchange_symbols: thread = threading.Thread(target=self._symbol_poll, args=[symbol, result]) thread.start() threads.append(thread) for thread in threads: thread.join() if len(result['coinpairs']) > 0: result['success'] = True return result def _symbol_poll(self, symbol, result): try: data = self.client.get_order_book(symbol, limit=1) if data['BUY'] is not None and data['SELL'] is not None: result['coinpairs'][self._get_arbitrager_coinpair(symbol)] = { 'buy': Decimal(str(data['BUY'][0][0])), 'buyAmount': Decimal(str(data['BUY'][0][1])), 'sell': Decimal(str(data['SELL'][0][0])), 'sellAmount': Decimal(str(data['SELL'][0][1])) } except (KucoinRequestException, KucoinAPIException) as e: print datetime.now(), "[Kucoin] market poll error", str(e).replace( '\r\n', '') self.errors += 1 # Gets the buy/sell price for all the symbols with one query but does not contain buy/sell amount (useless). @DeprecationWarning def market_poll_no_amount(self): threading.Timer(Consts.POLL_INTERVAL, self.market_poll_no_amount).start() timestamp = int(time.time() * 1000) try: coins = self.client.get_trading_symbols() if self.verbose: now = int(time.time() * 1000) print datetime.now( ), "[Kucoin] market_poll took", now - timestamp, "ms." except (KucoinRequestException, KucoinAPIException) as e: print datetime.now(), "[Kucoin] market poll error", str(e).replace( '\r\n', ' ') result = {'success': False} result['client'] = self return result result = {'success': True} result['client'] = self result['timestamp'] = timestamp result['coinpairs'] = {} for coin in coins: symbol = coin['symbol'] if symbol in self.exchange_symbols: result['coinpairs'][self._get_arbitrager_coinpair(symbol)] = { 'buy': Decimal(str(coin['buy'])), 'sell': Decimal(str(coin['sell'])) } # result['timestamp'] = coin['datetime'] if self.callback is None: print result else: self.callback(result)