def main(target_currency: str, mm1_name: str, mm2_name: str, st_local: str,
et_local: str):
Global.configure_default_root_logging(should_log_to_file=False)
SharedMongoClient.initialize(should_use_localhost_db=False)
start_time = Global.convert_local_datetime_to_epoch(st_local,
timezone="kr")
end_time = Global.convert_local_datetime_to_epoch(et_local, timezone="kr")
mm1_taker_fee = Global.read_market_fee(mm1_name, True)
mm1_maker_fee = Global.read_market_fee(mm1_name, False)
mm2_taker_fee = Global.read_market_fee(mm2_name, True)
mm2_maker_fee = Global.read_market_fee(mm2_name, False)
mm1_market = getattr(Market, "VIRTUAL_%s" % mm1_name.upper())
mm2_market = getattr(Market, "VIRTUAL_%s" % mm2_name.upper())
bal_setting = {
'mm1': {
'krw_balance': 0,
'coin_balance': 0.04475666666666667
},
'mm2': {
'krw_balance': 333333.3333333333,
'coin_balance': 0.0
}
}
initial_setting_dict = {
'max_trading_coin': 0.005,
'min_trading_coin': 0,
'new': {
'threshold': 0,
'factor': 1
},
'rev': {
'threshold': 0,
'factor': 1
}
}
mm1 = VirtualMarketManager(mm1_market, mm1_taker_fee, mm1_maker_fee,
bal_setting["mm1"]["krw_balance"],
bal_setting["mm1"]["coin_balance"],
target_currency, True)
mm2 = VirtualMarketManager(mm2_market, mm2_taker_fee, mm2_maker_fee,
bal_setting["mm2"]["krw_balance"],
bal_setting["mm2"]["coin_balance"],
target_currency, True)
mm1_col = SharedMongoClient.get_target_col(mm1_market, target_currency)
mm2_col = SharedMongoClient.get_target_col(mm2_market, target_currency)
mm1_data_cursor, mm2_data_cursor = SharedMongoClient.get_data_from_db(
mm1_col, mm2_col, start_time, end_time)
RfabBacktester(mm1, mm2,
target_currency).run(mm1_data_cursor,
mm2_data_cursor,
initial_setting_dict,
is_running_in_optimizer=False)
def __init__(self, market_tag: Market, market_api: MarketApi):
self.market_tag = market_tag
self.market_api = market_api
self.taker_fee = Global.read_market_fee(
exchange_name=self.market_tag.name, is_taker_fee=True)
self.maker_fee = Global.read_market_fee(
exchange_name=self.market_tag.name, is_taker_fee=False)
# init fee accumulator
GlobalFeeAccumulator.initialize_market(self.market_tag)
# Note that updating balance is already included in initialization phase
self.balance = Balance(self.get_market_name())
self.update_balance()
self.min_trading_coin_dict = dict()
def get_settings(mm1_name: str, mm2_name: str, target_currency: str,
start_time: int, end_time: int, division: int, depth: int,
consecution_time: int, is_virtual_mm: bool):
if is_virtual_mm:
mm1_tag = "VIRTUAL_%s" % mm1_name.upper()
mm2_tag = "VIRTUAL_%s" % mm2_name.upper()
elif not is_virtual_mm:
mm1_tag = mm1_name.upper()
mm2_tag = mm2_name.upper()
else:
raise Exception("Please type mm1 and mm2 correctly! ex) coinone")
return {
"target_currency": target_currency,
"mm1": {
"market_tag":
getattr(Market, mm1_tag),
"taker_fee":
Global.read_market_fee(mm1_name, is_taker_fee=True),
"maker_fee":
Global.read_market_fee(mm1_name, is_taker_fee=False),
"min_trading_coin":
Global.read_min_trading_coin(mm1_name, target_currency),
"krw_balance":
10000000,
"coin_balance":
100
},
"mm2": {
"market_tag":
getattr(Market, mm2_tag),
"taker_fee":
Global.read_market_fee(mm2_name, is_taker_fee=True),
"maker_fee":
Global.read_market_fee(mm2_name, is_taker_fee=False),
"min_trading_coin":
Global.read_min_trading_coin(mm2_name, target_currency),
"krw_balance":
10000000,
"coin_balance":
100
},
"division": division,
"depth": depth,
"consecution_time": consecution_time,
"start_time": start_time,
"end_time": end_time
}
def get_order_info(self, currency: GopaxCurrency, order: Order):
path = "/orders/" + order.order_id
headers = self.get_auth_headers("GET", path)
res = self._session.get(self.BASE_URL + path, headers=headers)
res_json = self.filter_successful_response(res)
# note that if res_json is empty it will return empty
# gopax api is currently removing the order entry when the order is completed or cancelled, which is very wrong.
if res_json is None:
return None
fee_rate = Global.read_market_fee("gopax", is_taker_fee=True)
order_amount = float(res_json["amount"])
remain_amount = float(res_json["remaining"])
filled_amount = order_amount - remain_amount
avg_filled_price = int(float(res_json["price"]))
if res_json["side"] == "buy":
fee = filled_amount * fee_rate
elif res_json["side"] == "sell":
fee = avg_filled_price * filled_amount * fee_rate
else:
fee = "null"
return {
"status": OrderStatus.get(res_json["status"]),
"avg_filled_price": avg_filled_price,
"order_amount": order_amount,
"filled_amount": filled_amount,
"remain_amount": remain_amount,
"fee": fee
}
def get_order_info(self, currency: OkcoinCurrency, order: Order):
sign = self.get_md5_sign(param_list=[
"symbol=%s" % currency.value,
"order_id=%s" % order.order_id
])
res_json = self.okcoin_post(self.BASE_URL + "/order_info.do",
data={
"api_key": self._api_key,
"symbol": currency.value,
"order_id": order.order_id,
"sign": sign
})
if not len(res_json["orders"]) > 0:
# note that the error will also be raised when the order has been cancelled
raise OkcoinError(res_json.get("code"),
"Order id does not exist: %s" % order.order_id)
fee_rate = Global.read_market_fee("okcoin", is_taker_fee=True)
order_info = res_json["orders"][0]
order_amount = float(order_info["amount"])
filled_amount = float(order_info["deal_amount"])
avg_filled_price = int(float(order_info["avg_price"]))
if order_info["type"] == "buy":
fee = filled_amount * fee_rate
elif order_info["type"] == "sell":
fee = avg_filled_price * filled_amount * fee_rate
else:
fee = "null"
# status: -1 = 취소 됨, 0 = 미체결, 1 = 부분 체결, 2 = 전부 체결, 3 = 주문취소 처리중
return {
"status": OrderStatus.get(order_info["status"]),
"avg_filled_price": avg_filled_price,
"order_amount": order_amount,
"filled_amount": filled_amount,
"remain_amount": order_amount - filled_amount,
# fee 제공안함.. RFAB용이므로 Taker Fee로 계산함
"fee": fee
}
