mmbot.py

import threading
from time import sleep
import sys
import configparser
from logging import getLogger, FileHandler, StreamHandler, Formatter, DEBUG
import traceback

logger = getLogger(name="delta_mm")
logger.setLevel(DEBUG)
handler1 = StreamHandler()
handler1.setFormatter(Formatter("%(asctime)s %(levelname)8s %(message)s"))
handler2 = FileHandler(filename="delta_mm.log")  # handler2はファイル出力
handler2.setFormatter(Formatter("%(asctime)s %(levelname)8s %(message)s"))
logger.addHandler(handler1)
logger.addHandler(handler2)

sys.path.append('../')
from Quoinex import realtime, order, position

class MMBot():

    def __init__(self, lot=0.01, spread_th=50, delta=-5, cancel_interval=10, order_interval=10):
        self.delta = delta
        self.spread_th = spread_th
        self.cancel_interval = cancel_interval
        self.order_interval = order_interval
        self.lot = lot
        self.board = realtime.Board()
        inifile = configparser.ConfigParser()
        inifile.read('../configs/config.ini', 'UTF-8-sig')
        key = inifile.get('quoinex', 'api_key')
        secret = inifile.get('quoinex', 'api_secret')
        self.order = order.Order(key, secret)
        self.position_manager = position.PositionManager(key, secret)
        self.net_position = 0

    def calculate_delta(self):
        return self.delta

    def get_spread(self):
        return self.board.get_spread()

    def get_net_position(self):
        return self.position_manager.get_net_position()
    
    def cancel_order(self, order_response):
        return self.order.api.cancel_order(id=order_response['id'])

    def order_task(self):
        try:
            print('======================================================')
            logger.info('Doing new order task.')
            best_ask, best_bid = self.board.get_best_order()
            product_id = self.order.api.get_btcjpy_id()
            buy_order_size, sell_order_size, pos_size = self.get_net_position()
            logger.info(f'Order size: buy({buy_order_size})BTC, sell({sell_order_size})BTC')
            logger.info(f'Net position: {self.net_position}')
            deviation_of_position = buy_order_size - sell_order_size + self.net_position
            buy_size = self.lot
            sell_size = self.lot
            if deviation_of_position > 0:
                sell_size += deviation_of_position
            elif deviation_of_position < 0:
                buy_size -= deviation_of_position
            buy_res = self.order.limit(product_id=product_id, side='buy', quantity=buy_size, price=best_bid-self.delta)
            sell_res = self.order.limit(product_id=product_id, side='sell', quantity=sell_size, price=best_ask+self.delta)
            logger.info(f'Sent buy order: {buy_res["quantity"]}BTC at {buy_res["price"]}')
            logger.info(f'Sent sell order: {sell_res["quantity"]}BTC at {sell_res["price"]}')
            sleep(self.cancel_interval)
            buy_filled = float(self.cancel_order(buy_res)['filled_quantity'])
            sell_filled = float(self.cancel_order(sell_res)['filled_quantity'])
            logger.info(f'Filled buy: {buy_filled}, sell: {sell_filled}')
            self.net_position += buy_filled - sell_filled
            print('======================================================')
        except:
            logger.debug(buy_res)
            logger.debug(traceback.format_exc())
            
    def main_loop(self):
        while len(self.board.asks.ladders) * len(self.board.bids.ladders) == 0:
            continue
        while True:
            if self.get_spread() > self.spread_th:
                logger.info(f'Spread is the over threshold: {self.spread_th}')
                threading.Thread(target=self.order_task).start()
                sleep(self.order_interval)

def main():
    mmbot = MMBot(lot=0.001)
    mmbot.main_loop()

if __name__ == '__main__':
    main()