示例#1
0
    def __init__(self):
        # read configuration from json file
        with open('config.json', 'r') as file:
            config = json.load(file)

        self.api_key = config['api_key']
        self.api_secret = config['api_secret']
        self.api_passphrase = config['api_passphrase']
        self.sandbox = config['is_sandbox']
        self.symbol = config['symbol']
        self.leverage = config['leverage']
        self.size = config['size']
        self.depth = config['depth']
        self.market = Market(self.api_key,
                             self.api_secret,
                             self.api_passphrase,
                             is_sandbox=self.sandbox)
        self.trade = Trade(self.api_key,
                           self.api_secret,
                           self.api_passphrase,
                           is_sandbox=self.sandbox)

        self.tick_size = 0
        self.best_ask = 0
        self.best_bid = 0
        self.diff = 0
        self.max_ask = 0
        self.max_bid = 0
        self.precision = 0
        self.ask_list = {}
        self.bid_list = {}
示例#2
0
    def sell(self, coin_name, quantity=None, pair_base="BTC", amount=None, order_type="market"):
        try:
            client = Trade(key=self.api_key, secret=self.api_secret, passphrase='chimera',
                           is_sandbox=self.debug_mode)
            symbol = f"BTC-{coin_name}"
            price = self.get_price(symbol)
            balance = self.get_balance(coin_name)

            quantity = self.calculate_sell_qty(price, amount)

            precision = self.get_precision(coin_name)
            price = self.round_value(price, precision)
            quantity = self.round_value(quantity, precision)

            logger.info(
                f"symbol:{symbol}>price:{price}>qty:{quantity} > market: {order_type}")

            if order_type.lower() == "market":
                order_id = client.create_market_order(
                    symbol, 'sell', size=quantity)
            elif order_type.lower() == "limit":
                order_id = client.create_limit_order(
                    symbol, 'sell', quantity, amount)
            logger.info(
                f"sold order request:{symbol}>type:{order_type}>quantity:{quantity}")
            return order_id
        except Exception as ex:
            logger.error(ex, exc_info=True)
            raise UserAdviceException(ex)
示例#3
0
    def __init__(self):
        # read configuration from json file
        with open('config.json', 'r') as file:
            config = json.load(file)

        self.api_key = config['api_key']
        self.api_secret = config['api_secret']
        self.api_passphrase = config['api_passphrase']
        self.sandbox = config['is_sandbox']
        self.symbol = config['symbol']
        self.min_param = float(config['min_param'])
        self.price_param = float(config['price_param'])
        self.market = Market(self.api_key,
                             self.api_secret,
                             self.api_passphrase,
                             is_sandbox=self.sandbox)
        self.user = User(self.api_key,
                         self.api_secret,
                         self.api_passphrase,
                         is_sandbox=self.sandbox)
        self.trade = Trade(self.api_key,
                           self.api_secret,
                           self.api_passphrase,
                           is_sandbox=self.sandbox)
        self.symbol_trade = self.symbol + '-USDT'
    def __init__(self):
        # read configuration from json file
        with open(c.CONFIG_FILE, 'r') as file:
            config = json.load(file)

        self.api_key = config['kucoin_api_key']
        self.secret_key = config['kucoin_secret_key']
        self.pass_phrase = config['kucoin_pass_phrase']
        self.is_sandbox = config['is_sandbox']
        self.kucoin_symbol = config['kucoin_symbol']
        self.category = config['category']
        self.maker_number = config['maker_number']
        self.taker_number = config['taker_number']
        self.side = config['side']
        self.sizeMin = 100
        self.sizeMax = 10000

        self.buy_list = {}
        self.sell_list = {}
        self.best_ask = 0
        self.best_bid = 0
        self.market_price = 0

        self.trade_sandbox = Trade(self.api_key,
                                   self.secret_key,
                                   self.pass_phrase,
                                   is_sandbox=self.is_sandbox)
        self.market_sandbox = Market(self.api_key,
                                     self.secret_key,
                                     self.pass_phrase,
                                     is_sandbox=self.is_sandbox)
        self.trade = Trade(self.api_key,
                           self.secret_key,
                           self.pass_phrase,
                           is_sandbox=False)
        self.market = Market(self.api_key,
                             self.secret_key,
                             self.pass_phrase,
                             is_sandbox=False)
                order['symbol'], order['type'], order['side'], order['timeInForce'],
                order['transactTime'], order['fills'][0]['commissionAsset'], 
                order['fills'][0]['price'], order['fills'][0]['commission'],
                order['fills'][0]['qty'], order['cummulativeQuoteQty']))
    
    conn.commit()


if __name__ == '__main__':

    show_header()

    client = Market(url='https://openapi-sandbox.kucoin.com')
    # client = Client(config["api_key"], config["api_secret"])

    trade = Trade(config['api_key'], config['api_secret'], config['api_passphrase'], is_sandbox=True)
    user_client = User(config['api_key'], config['api_secret'], config['api_passphrase'], is_sandbox=True)

    if config['debug_mode']:
        debug_mode(client=client)
        print('\n')

    print(Fore.GREEN + '-- Kucoin Edition --\n' + Fore.RESET)

    #Question1
    answer1 = Inquirer.prompt(question1)
    selected_config = answer1['trade_conf']

    #Retrieve current coin balance here
    balance = acct_balance()
示例#6
0
    liste = Market.get_symbol_list()
    element = list(filter(lambda item: item['symbol'] == symbol, liste))
    return element[0]['baseMinSize']

def returnIncrementSize(symbol):
    '''
    :param symbol: a trading pair ('BTC-USDT',...)
    :return: The increment of the order size.
    '''
    liste = Market.get_symbol_list()
    element = list(filter(lambda item: item['symbol'] == symbol, liste))
    return Decimal(element[0]['baseIncrement'])

# Trade
from kucoin.client import Trade
client = Trade(api_key, api_secret, api_passphrase)

# or connect to Sandbox
# client = Trade(api_key, api_secret, api_passphrase, is_sandbox=True)
class pair(Thread):
    def __init__(self, symbol, currency):
        Thread.__init__(self)
        self.symbol = symbol
        self.currency = currency



    def run(self):
        while (1):
            price = returnPrice(self.symbol)
            bid = returnBid(self.symbol)
示例#7
0
from kucoin.client import Market
from kucoin.client import Trade

# Sandbox Market
client = Market(url='https://openapi-sandbox.kucoin.com')
# Sandbox Trade
client = Trade(api_key, api_secret, api_passphrase, is_sandbox=True)

time = client.get_timestamp()
print(time)
示例#8
0
# User
from kucoin.client import User
user = User(api_key, api_secret, api_passphrase)

# or connect to Sandbox
#user = User(api_key, api_secret, api_passphrase, is_sandbox=True)


def returnPrice(token):
    account = market.get_ticker(token)
    return account['price']


# Trade
from kucoin.client import Trade
client = Trade(api_key, api_secret, api_passphrase)

# or connect to Sandbox
# client = Trade(api_key, api_secret, api_passphrase, is_sandbox=True)# Trade

while (1):
    debut = time.time()
    bid = returnBid('BTC-USDT')
    try:
        order = client.create_limit_order('BTC-USDT', 'sell',
                                          randint(1, txMax), bid)
        print(order)
        fin = time.time()
        print(fin - debut)
        time.sleep(randint(10, 120))
    except Exception as err:
    insert_into_db(order=sell_order_data, order_id=sell_order['orderId'])

    conn.close()

    balance2 = acct_balance2()
    pump_duration(start_time, end_time)


if __name__ == '__main__':

    show_header()

    client = Market(url='https://api.kucoin.com')
    trade = Trade(key=config['api_key'],
                  secret=config['api_secret'],
                  passphrase=config['api_passphrase'],
                  is_sandbox=False,
                  url='')
    user_client = User(config['api_key'], config['api_secret'],
                       config['api_passphrase'])

    if config['debug_mode']:
        debug_mode(client=client)
        print('\n')

    print(Fore.GREEN + '-- Kucoin Edition --\n' + Fore.RESET)

    #Question1
    answer1 = Inquirer.prompt(question1)
    selected_config = answer1['trade_conf']
示例#10
0
if __name__ == '__main__':
    # read configuration from json file
    with open('config.json', 'r') as file:
        config = json.load(file)

    api_key = config['api_key']
    api_secret = config['api_secret']
    api_passphrase = config['api_passphrase']
    symbol = config['symbol']
    min_param = config['min_param']
    price_param = config['price_param']
    sandbox = config['is_sandbox']
    market = Market(api_key, api_secret, api_passphrase, is_sandbox=sandbox)
    user = User(api_key, api_secret, api_passphrase, is_sandbox=sandbox)
    trade = Trade(api_key, api_secret, api_passphrase, is_sandbox=sandbox)
    init_ticker = market.get_ticker(symbol+'-USDT')
    init_price = float(init_ticker['price'])
    print('init_price =', init_price)

    while 1:
        time.sleep(1)
        # account balance
        symbol_balance = user.get_account_list(symbol, 'trade')
        available_symbol = float(symbol_balance[0]['available'])
        print('symbol_balance =', available_symbol)
        usdt_balance = user.get_account_list('USDT', 'trade')
        available_usdt = float(usdt_balance[0]['available'])
        print('usdt_balance =', available_usdt)
        now_symbol = market.get_ticker(symbol+'-USDT')
        now_price = float(now_symbol['price'])
class Kucoin(object):
    def __init__(self):
        # read configuration from json file
        with open(c.CONFIG_FILE, 'r') as file:
            config = json.load(file)

        self.api_key = config['kucoin_api_key']
        self.secret_key = config['kucoin_secret_key']
        self.pass_phrase = config['kucoin_pass_phrase']
        self.is_sandbox = config['is_sandbox']
        self.kucoin_symbol = config['kucoin_symbol']
        self.category = config['category']
        self.maker_number = config['maker_number']
        self.taker_number = config['taker_number']
        self.side = config['side']
        self.sizeMin = 100
        self.sizeMax = 10000

        self.buy_list = {}
        self.sell_list = {}
        self.best_ask = 0
        self.best_bid = 0
        self.market_price = 0

        self.trade_sandbox = Trade(self.api_key,
                                   self.secret_key,
                                   self.pass_phrase,
                                   is_sandbox=self.is_sandbox)
        self.market_sandbox = Market(self.api_key,
                                     self.secret_key,
                                     self.pass_phrase,
                                     is_sandbox=self.is_sandbox)
        self.trade = Trade(self.api_key,
                           self.secret_key,
                           self.pass_phrase,
                           is_sandbox=False)
        self.market = Market(self.api_key,
                             self.secret_key,
                             self.pass_phrase,
                             is_sandbox=False)

    def get_market_price(self):
        r = {}
        # 根据类型调用对应的合约API
        try:
            if self.category == c.BTC_USDT:
                r = self.market.get_ticker(self.kucoin_symbol)
            elif self.category == c.ETH_USDT:
                r = self.market.get_ticker(self.kucoin_symbol)
            elif self.category == c.ETH_BTC:
                r = self.market.get_ticker(self.kucoin_symbol)
        except Exception as e:
            logging.error(e)
            time.sleep(5)
        self.best_ask = int(float(r['bestAsk']))
        self.best_bid = int(float(r['bestBid']))
        self.market_price = int((self.best_ask + self.best_bid) / 2)
        logging.info('最新盘口价格 = %s' % self.market_price)

    def taker(self):
        try:
            t = self.market_sandbox.get_ticker(self.kucoin_symbol)
            logging.info(t)
            best_bid_size = t['bestBidSize']
            best_ask_size = t['bestAskSize']
            max_size = 100000
            if best_bid_size > max_size:
                best_bid_size = max_size
            if best_ask_size > max_size:
                best_ask_size = max_size

            if best_ask_size > 0:
                try:
                    sell = self.trade_sandbox.create_market_order(
                        self.kucoin_symbol,
                        'sell',
                        size=best_ask_size,
                        type='market')
                    logging.info(
                        '在交易对 %s 以数量= %s, 吃卖单,订单ID = %s' %
                        (self.kucoin_symbol, best_ask_size, sell['orderId']))
                except Exception as e:
                    logging.error(e)
            if best_bid_size > 0:
                try:
                    buy = self.trade_sandbox.create_market_order(
                        self.kucoin_symbol,
                        'buy',
                        size=best_bid_size,
                        type='market')
                    logging.info(
                        '在交易对 %s 以数量= %s, 吃买单,订单ID = %s' %
                        (self.kucoin_symbol, best_bid_size, buy['orderId']))
                except Exception as e:
                    logging.error(e)
        except Exception as e:
            logging.error(e)
            return

    def ask_maker(self, p):
        try:
            m = random.randint(self.sizeMin, self.sizeMax)
            ask = self.trade_sandbox.create_limit_order(
                self.kucoin_symbol, 'sell', m, p)
            logging.info(
                '当前盘口价格 = %s,在交易对 %s 以数量= %s,价格= %s,创建了卖单,卖单ID = %s' %
                (self.market_price, self.kucoin_symbol, m, p, ask['orderId']))
            self.sell_list[p] = {
                'price': p,
                'side': 'sell',
                'size': m,
                'order_id': ask['orderId']
            }
        except Exception as e:
            logging.error(e)

    def bid_maker(self, p):
        try:
            m = random.randint(self.sizeMin, self.sizeMax)
            bid = self.trade_sandbox.create_limit_order(
                self.kucoin_symbol, 'buy', m, p)
            logging.info(
                '当前盘口价格 = %s,在交易对 %s 以数量= %s,价格= %s,创建了买单,卖单ID = %s' %
                (self.market_price, self.kucoin_symbol, m, p, bid['orderId']))
            self.sell_list[p] = {
                'price': p,
                'side': 'buy',
                'size': m,
                'order_id': bid['orderId']
            }
        except Exception as e:
            logging.error(e)

    def cancel_order(self, order_id, key, side):
        try:
            self.trade_sandbox.cancel_order(order_id)
            logging.info('当前盘口价 = %s,撤单 id = %s, key = %s' %
                         (self.market_price, order_id, key))
            if side == 'sell':
                del self.sell_list[key]
            elif side == 'buy':
                del self.buy_list[key]
        except Exception as e:
            logging.info('撤单时发生错误, order_id = %s, key = %s' % (order_id, key))
            logging.error(e)

    def get_order_info(self, order_id):
        try:
            o = self.trade_sandbox.get_order_details(order_id)
        except Exception as e:
            logging.error(e)
            o = {}
        return o

    def get_active_orders(self):
        try:
            o = self.trade_sandbox.get_order_list(symbol=self.kucoin_symbol,
                                                  status='active',
                                                  type='limit')
            os = o['items']
        except Exception as e:
            logging.error(e)
            os = []
        if len(os) > 0:
            self.sell_list.clear()
            self.buy_list.clear()
            for n in os:
                # print(json.dumps(n))
                if n['side'] == 'sell':
                    self.sell_list[int(n['price'])] = {
                        'price': int(n['price']),
                        'side': 'sell',
                        'size': n['size'],
                        'order_id': n['id']
                    }
                elif n['side'] == 'buy':
                    self.buy_list[int(n['price'])] = {
                        'price': int(n['price']),
                        'side': 'buy',
                        'size': n['size'],
                        'order_id': n['id']
                    }
示例#12
0
        ("Kucoin", order['clientOid'], order_id, order['id'], order['symbol'],
         order['type'], order['side'], order['timeInForce'],
         order['createdAt'], symbol, price, order['fee'], order['size'],
         order['dealFunds']))

    conn.commit()


if __name__ == '__main__':

    show_header()

    client = Market(url='https://api.kucoin.com')
    trade = Trade(key=config['api_key'],
                  secret=config['api_secret'],
                  passphrase=config['api_passphrase'],
                  is_sandbox=False,
                  url='')
    user_client = User(config['api_key'], config['api_secret'],
                       config['api_passphrase'])

    if config['debug_mode']:
        debug_mode(client=client)
        print('\n')

    print(Fore.GREEN + '-- Kucoin Edition --\n' + Fore.RESET)

    #Question1
    answer1 = Inquirer.prompt(question1)
    selected_config = answer1['trade_conf']
示例#13
0
class Grid(object):
    def __init__(self):
        # read configuration from json file
        with open('config.json', 'r') as file:
            config = json.load(file)

        self.api_key = config['api_key']
        self.api_secret = config['api_secret']
        self.api_passphrase = config['api_passphrase']
        self.sandbox = config['is_sandbox']
        self.symbol = config['symbol']
        self.leverage = config['leverage']
        self.size = config['size']
        self.depth = config['depth']
        self.market = Market(self.api_key,
                             self.api_secret,
                             self.api_passphrase,
                             is_sandbox=self.sandbox)
        self.trade = Trade(self.api_key,
                           self.api_secret,
                           self.api_passphrase,
                           is_sandbox=self.sandbox)

        self.tick_size = 0
        self.best_ask = 0
        self.best_bid = 0
        self.diff = 0
        self.max_ask = 0
        self.max_bid = 0
        self.precision = 0
        self.ask_list = {}
        self.bid_list = {}

    def get_symbol(self):
        symbols = self.market.get_symbol_list()
        ks = {}
        for s in symbols:
            if s.get('symbol') and s.get('symbol') == self.symbol:
                ks = s
        if ks:
            self.tick_size = Decimal(ks['priceIncrement'])
            self.diff = Decimal(self.tick_size * self.depth)
            self.precision = int(1 / Decimal(ks['baseIncrement']))

            logging.debug('tick_size = %s, precision = %s', self.tick_size,
                          self.precision)

    def get_market_price(self):
        try:
            r = self.market.get_ticker(self.symbol)
            if 'bestAsk' in r.keys():
                self.best_ask = Decimal(r['bestAsk'])
                self.max_ask = Decimal(self.best_ask + self.diff).quantize(
                    Decimal("0.00"))
            else:
                return
            if 'bestBid' in r.keys():
                self.best_bid = Decimal(r['bestBid'])
                self.max_bid = Decimal(self.best_bid - self.diff).quantize(
                    Decimal("0.00"))
            else:
                return
            logging.debug('最新卖价格 = %s' % self.best_ask)
            logging.debug('最新买价格 = %s' % self.best_bid)
        except Exception as e:
            logging.error(e)
            time.sleep(5)

    def cancel_order(self, order_id, side):
        try:
            oi = self.trade.get_order_details(order_id)
            if oi['isActive']:
                self.trade.cancel_order(order_id)

            if side == 'sell':
                del self.ask_list[order_id]
            elif side == 'buy':
                del self.bid_list[order_id]
        except Exception as e:
            logging.error('该订单状态不可撤回 side = %s, order_id = %s' %
                          (side, order_id))
            logging.error(e)

    def ask_maker(self, p):
        try:
            price = int(p * 100) / 100
            ask = self.trade.create_limit_order(self.symbol, 'sell', self.size,
                                                float(price))
            logging.debug(
                '当前盘口价格 = %s,在交易对 %s 以数量= %s,价格= %s,创建了卖单,卖单ID = %s' %
                (self.best_ask, self.symbol, self.size, float(price),
                 ask['orderId']))
            self.ask_list[ask['orderId']] = {'price': p}
        except Exception as e:
            logging.error(e)

    def bid_maker(self, p):
        try:
            price = int(p * 100) / 100
            bid = self.trade.create_limit_order(self.symbol, 'buy', self.size,
                                                float(price))
            logging.debug(
                '当前盘口价格 = %s,在交易对 %s 以数量= %s,价格= %s,创建了买单,卖单ID = %s' %
                (self.best_ask, self.symbol, self.size, float(price),
                 bid['orderId']))
            self.bid_list[bid['orderId']] = {'price': p}
        except Exception as e:
            logging.error(e)