88 lines
2.3 KiB
Python
88 lines
2.3 KiB
Python
import asyncio
|
|
|
|
class MM:
|
|
def __init__(self, logger, pair, lot, epsilon):
|
|
self._logger = logger
|
|
self._pair = pair
|
|
self._lot = lot
|
|
self._remain = 0
|
|
self._epsilon = epsilon
|
|
|
|
asyncio.create_task(self._main())
|
|
|
|
async def _main(self):
|
|
self._logger.info("started")
|
|
while True:
|
|
depth = self._pair.depth
|
|
await depth.wait()
|
|
if len(depth.bids) == 0 or len(depth.asks) == 0:
|
|
continue
|
|
|
|
spread = depth.asks[0][0] - depth.bids[0][0]
|
|
if spread > self._epsilon*2:
|
|
sell_price = depth.asks[0][0]-self._epsilon
|
|
buy_price = depth.bids[0][0]+self._epsilon
|
|
await self._make(sell_price, buy_price)
|
|
|
|
async def _make(self, sell_price, buy_price):
|
|
if self._remain < self._epsilon/buy_price:
|
|
amount = self._lot/buy_price
|
|
try:
|
|
buy = await self._pair.buy_limit(amount, buy_price, True)
|
|
except Exception:
|
|
buy = None
|
|
try:
|
|
sell = await self._pair.sell_limit(amount, sell_price, True)
|
|
except Exception:
|
|
sell = None
|
|
else:
|
|
buy = None
|
|
try:
|
|
sell = await self._pair.sell_limit(self._remain, sell_price, True)
|
|
except Exception:
|
|
sell = None
|
|
|
|
while (sell is not None) or (buy is not None):
|
|
await asyncio.sleep(1)
|
|
try:
|
|
coro = []
|
|
if buy is not None: coro.append(buy .update())
|
|
if sell is not None: coro.append(sell.update())
|
|
await asyncio.gather(*coro)
|
|
except Exception as e:
|
|
continue
|
|
|
|
depth = self._pair.depth
|
|
|
|
if sell is not None:
|
|
if sell.done:
|
|
self._remain -= sell.amount-sell.remain
|
|
sell = None
|
|
elif sell_price > depth.asks[0][0]:
|
|
break
|
|
|
|
if buy is not None:
|
|
if buy.done:
|
|
self._remain += buy.amount-buy.remain
|
|
buy = None
|
|
elif buy_price < depth.bids[0][0]:
|
|
break
|
|
|
|
async def cancel(self, order, flag):
|
|
while True:
|
|
try:
|
|
await asyncio.sleep(1)
|
|
await order.cancel()
|
|
await order.update()
|
|
break
|
|
except Exception:
|
|
continue
|
|
self._remain += flag*(order.amount-order.remain)
|
|
|
|
coro = []
|
|
if sell is not None:
|
|
coro.append(cancel(self, sell, -1))
|
|
if buy is not None:
|
|
coro.append(cancel(self, buy, 1))
|
|
await asyncio.gather(*coro)
|