133 lines
4.0 KiB
Python
133 lines
4.0 KiB
Python
import asyncio
|
|
|
|
|
|
RESET_RATIO = 0
|
|
|
|
class MM:
|
|
def __init__(self, logger, pair, lot, epsilon):
|
|
self._logger = logger
|
|
self._pair = pair
|
|
self._lot = lot
|
|
self._remain = 0
|
|
self._epsilon = epsilon
|
|
|
|
self._buy_price = None
|
|
self._sell_price = None
|
|
self._buy = None
|
|
self._sell = None
|
|
|
|
self._buy_amount_sum = 0
|
|
self._sell_amount_sum = 0
|
|
self._income_sum = 0
|
|
self._outgo_sum = 0
|
|
|
|
self._total = 0
|
|
|
|
asyncio.create_task(self._main())
|
|
|
|
async def _main(self):
|
|
self._logger.info("started")
|
|
while True:
|
|
pair = self._pair
|
|
depth = pair.depth
|
|
|
|
await depth.wait()
|
|
if len(depth.bids) == 0 or len(depth.asks) == 0:
|
|
continue
|
|
|
|
ask = depth.asks[0][0]
|
|
bid = depth.bids[0][0]
|
|
enough_spread = (ask-bid) > self._epsilon*2
|
|
|
|
# calculate buy/sell thresh
|
|
buy_max = 1e100
|
|
sell_min = 0
|
|
if self._sell_amount_sum > 0:
|
|
buy_max = self._income_sum / self._sell_amount_sum
|
|
if self._buy_amount_sum > 0:
|
|
sell_min = self._outgo_sum / self._buy_amount_sum
|
|
|
|
loss_cut = \
|
|
(buy_max - bid)/bid > 0.1 or \
|
|
(ask - sell_min)/ask > 0.1
|
|
|
|
# reset thresh if stock is consumed or to do cut loss
|
|
if self._remain < self._lot or loss_cut:
|
|
self._sell_amount_sum = 0
|
|
self._income_sum = 0
|
|
self._buy_amount_sum = 0
|
|
self._outgo_sum = 0
|
|
|
|
if self._sell is not None:
|
|
# check current SELL order
|
|
await asyncio.sleep(0.5)
|
|
await self._sell.update()
|
|
|
|
# get highest ask
|
|
if ask == self._sell_price and depth.asks[0][1] > self._sell.remain:
|
|
ask = depth.asks[1][0]
|
|
|
|
if self._sell.done:
|
|
amount = self._sell.amount - self._sell.remain
|
|
if amount > 0:
|
|
income = amount*self._sell.price
|
|
self._sell_amount_sum += amount
|
|
self._income_sum += income
|
|
self._total += income
|
|
self._logger.info(f"<SELL> {amount} / {income} ({self._total})")
|
|
self._remain -= self._sell.amount - self._sell.remain
|
|
self._sell = None
|
|
elif self._sell_price != max(sell_min, ask-self._epsilon):
|
|
try:
|
|
await self._sell.cancel()
|
|
except Exception:
|
|
pass
|
|
elif enough_spread:
|
|
# order SELL
|
|
self._sell_price = max(sell_min, ask-self._epsilon)
|
|
amount = self._lot
|
|
if self._remain > self._lot*2:
|
|
amount = self._remain - self._lot
|
|
elif self._remain < self._lot:
|
|
amount = 0
|
|
if amount > 0:
|
|
self._sell = await self._order_sell(amount)
|
|
|
|
if self._buy is not None:
|
|
# check current BUY order
|
|
await asyncio.sleep(0.5)
|
|
await self._buy.update()
|
|
|
|
# get lowest bid
|
|
if bid == self._buy_price and depth.bids[0][1] > self._buy.remain:
|
|
bid = depth.bids[1][0]
|
|
|
|
if self._buy.done:
|
|
amount = self._buy.amount - self._buy.remain
|
|
if amount > 0:
|
|
outgo = amount*self._buy.price
|
|
self._buy_amount_sum += amount
|
|
self._outgo_sum += outgo
|
|
self._total -= outgo
|
|
self._logger.info(f"<BUY> {amount} / {outgo} ({self._total})")
|
|
self._remain += self._buy.amount - self._buy.remain
|
|
self._buy = None
|
|
elif self._buy_price != min(buy_max, bid+self._epsilon):
|
|
try:
|
|
await self._buy.cancel()
|
|
except Exception:
|
|
pass
|
|
elif enough_spread:
|
|
# order BUY
|
|
self._buy_price = min(buy_max, bid+self._epsilon)
|
|
amount = self._lot
|
|
if self._remain > self._lot*2:
|
|
amount = 0
|
|
if amount > 0:
|
|
self._buy = await self._order_buy(amount)
|
|
|
|
async def _order_sell(self, amount):
|
|
return await self._pair.sell_limit(amount, self._sell_price, True)
|
|
async def _order_buy(self, amount):
|
|
return await self._pair.buy_limit(amount, self._buy_price, True)
|