def fetch_market(self, market_id):
"""
Fetch and cache it. It rarely changes, except for base exchange rate, so assume it once for all.
@todo min/max/step/min_notional
"""
instrument = self.connector.ws.get_instrument(market_id)
# funds = self.connector.ws.funds() # to get account base currency (if XBt or XBT)
xbt_usd = self.connector.ws.get_instrument("XBTUSD")
if instrument:
# tickSize is the minimum price increment (0.5USD for XBTUSD)
tradeable = instrument.get('state', 'Closed') == 'Open'
update_time = self._parse_datetime(instrument.get('timestamp')).timestamp()
symbol = instrument.get('symbol', '')
base_symbol = instrument.get('rootSymbol', '')
quote_symbol = symbol[-3:]
# if funds['currency'] == 'XBt':
# # XBt to XBT
# ratio = 1.0 / 100000000.0
# if base_symbol == 'USD':
# # USD is base then convert to XBT
# ratio *= to_base_rate
bid = instrument.get('bidPrice')
ofr = instrument.get('askPrice')
market = Market(market_id, symbol)
# compute base precision from the tick size, example 0.05 => 2
base_precision = -math.floor(math.log10(instrument.get('tickSize', 1.0)))
market.set_base(base_symbol, base_symbol, base_precision)
market.set_quote(quote_symbol, quote_symbol)
# base to XBT
market.base_exchange_rate = 1.0
# base instrument
base_market_id = "XBT" + quote_symbol
base_market = self.connector.ws.get_instrument(base_market_id)
if base_market_id != symbol and base_market:
market.base_exchange_rate = base_market.get('lastPrice', 1.0) / instrument.get('lastPrice', 1.0)
# @todo 'multiplier', 'riskStep', 'riskLimit'
# limits
min_notional = 1.0 # $
if quote_symbol != "USD" and base_market_id != "XBT":
# any contract on futur XBT quote
min_notional = 0.0001
# BCHXBT 'maxOrderQty': 100000000, 'maxPrice': 10, 'lotSize': 1, 'tickSize': 0.0001,
# XBCUSD 'maxOrderQty': 10000000, 'maxPrice': 1000000, 'lotSize': 1, 'tickSize': 0.5,
market.set_size_limits(instrument.get('tickSize', 1.0), instrument.get('maxOrderQty', 0.0), instrument.get('tickSize', 1.0))
market.set_notional_limits(min_notional, instrument.get('maxPrice', 0.0), 0.0)
market.set_price_limits(0.0, 0.0, instrument.get('tickSize', 1.0))
# need to divided by account currency XBt = 100000000
market.margin_factor = instrument.get('initMargin', 1.0)
# market.max_margin_factor = 1.0 / (instrument.get('riskLimit', 1.0) * ratio) # ex: 20000000000 for max leverage 200
# '-' if perpetual else match the regexp and keep the expiry part only
expiry = BitMexWatcher.EXPIRY_RE.match(market_id)
# or instrument.get(expiry') == '2018-12-28T12:00:00.000Z' for Z18 its 28 of month Z (december) and year 2018
if expiry is None:
market.expiry = '-'
else:
market.expiry = expiry.group(2) + expiry.group(3)
market.market_type = Market.TYPE_CRYPTO
market.unit_type = Market.UNIT_CONTRACTS
market.contract_type = Market.CONTRACT_CFD # and FUTUR
market.trade = Market.TRADE_IND_MARGIN
if bid is not None and ofr is not None:
market.bid = bid
market.ofr = ofr
market.last_update_time = update_time
market.lot_size = instrument.get('lotSize', 1.0) # ex: 1.0 for XBTUSD
market.contract_size = 1.0
market.value_per_pip = 1.0
market.one_pip_means = instrument.get('tickSize', 1.0)
# contract_size need to be updated as price changes
# @todo this is wrong... same on update part above
if quote_symbol == 'USD' and base_market_id == symbol: # XBTUSD...
market.contract_size = 1.0 / instrument.get('lastPrice', 1.0)
elif quote_symbol == 'USD' and base_market_id != symbol: # ETHUSD...
market.contract_size = (0.001 * 0.01) * instrument.get('lastPrice', 1.0)
elif base_market and base_market_id != symbol: # ADAZ18...
market.contract_size = 1.0 / instrument.get('lastPrice', 1.0)
market.value_per_pip = market.contract_size / instrument.get('lastPrice', 1.0)
market.maker_fee = instrument.get('makerFee', 0.0)
market.taker_fee = instrument.get('takerFee', 0.0)
# store the last market info to be used for backtesting
if not self._read_only:
Database.inst().store_market_info((self.name, market_id, market.symbol,
market.market_type, market.unit_type, market.contract_type, # type
market.trade, market.orders, # type
market.base, market.base_display, market.base_precision, # base
market.quote, market.quote_display, market.quote_precision, # quote
market.expiry, int(market.last_update_time * 1000.0), # expiry, timestamp
str(market.lot_size), str(market.contract_size), str(market.base_exchange_rate),
str(market.value_per_pip), str(market.one_pip_means), str(market.margin_factor),
str(market.min_size), str(market.max_size), str(market.step_size), # size limits
str(market.min_notional), str(market.max_notional), str(market.step_notional), # notional limits
str(market.min_price), str(market.max_price), str(market.tick_price), # price limits
str(market.maker_fee), str(market.taker_fee), str(market.maker_commission), str(market.taker_commission)) # fees
)
# notify for strategy
self.service.notify(Signal.SIGNAL_MARKET_INFO_DATA, self.name, (market_id, market))
return market
def process_market(self):
#
# insert market info
#
with self._mutex:
mki = self._pending_market_info_insert
self._pending_market_info_insert = []
if mki:
try:
cursor = self._db.cursor()
for mi in mki:
if mi[16] is None:
# margin factor is unavailable when market is down, so use previous value if available
cursor.execute("""SELECT margin_factor FROM market WHERE broker_id = '%s' AND market_id = '%s'""" % (mi[0], mi[1]))
row = cursor.fetchone()
if row:
# replace by previous margin factor from the DB
margin_factor = row[0]
mi = list(mi)
mi[16] = margin_factor
else:
mi[16] = "1.0"
cursor.execute("""INSERT INTO market(broker_id, market_id, symbol,
market_type, unit_type, contract_type,
trade_type, orders,
base, base_display, base_precision,
quote, quote_display, quote_precision,
expiry, timestamp,
lot_size, contract_size, base_exchange_rate,
value_per_pip, one_pip_means, margin_factor,
min_size, max_size, step_size,
min_notional, max_notional, step_notional,
min_price, max_price, step_price,
maker_fee, taker_fee, maker_commission, taker_commission)
VALUES(%s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s)
ON CONFLICT (broker_id, market_id) DO UPDATE SET symbol = EXCLUDED.symbol,
market_type = EXCLUDED.market_type, unit_type = EXCLUDED.unit_type, contract_type = EXCLUDED.contract_type,
trade_type = EXCLUDED.trade_type, orders = EXCLUDED.orders,
base = EXCLUDED.base, base_display = EXCLUDED.base_display, base_precision = EXCLUDED.base_precision,
quote = EXCLUDED.quote, quote_display = EXCLUDED.quote_display, quote_precision = EXCLUDED.quote_precision,
expiry = EXCLUDED.expiry, timestamp = EXCLUDED.timestamp,
lot_size = EXCLUDED.lot_size, contract_size = EXCLUDED.contract_size, base_exchange_rate = EXCLUDED.base_exchange_rate,
value_per_pip = EXCLUDED.value_per_pip, one_pip_means = EXCLUDED.one_pip_means, margin_factor = EXCLUDED.margin_factor,
min_size = EXCLUDED.min_size, max_size = EXCLUDED.max_size, step_size = EXCLUDED.step_size,
min_notional = EXCLUDED.min_notional, max_notional = EXCLUDED.max_notional, step_notional = EXCLUDED.step_notional,
min_price = EXCLUDED.min_price, max_price = EXCLUDED.max_price, step_price = EXCLUDED.step_price,
maker_fee = EXCLUDED.maker_fee, taker_fee = EXCLUDED.taker_fee, maker_commission = EXCLUDED.maker_commission, taker_commission = EXCLUDED.taker_commission""",
(*mi,))
self._db.commit()
except self.psycopg2.OperationalError as e:
self.try_reconnect(e)
# retry the next time
with self._mutex:
self._pending_market_info_insert = mki + self._pending_market_info_insert
except Exception as e:
self.on_error(e)
# retry the next time
with self._mutex:
self._pending_market_info_insert = mki + self._pending_market_info_insert
#
# select market info
#
with self._mutex:
mis = self._pending_market_info_select
self._pending_market_info_select = []
if mis:
try:
cursor = self._db.cursor()
for mi in mis:
cursor.execute("""SELECT symbol,
market_type, unit_type, contract_type,
trade_type, orders,
base, base_display, base_precision,
quote, quote_display, quote_precision,
expiry, timestamp,
lot_size, contract_size, base_exchange_rate,
value_per_pip, one_pip_means, margin_factor,
min_size, max_size, step_size,
min_notional, max_notional, step_notional,
min_price, max_price, step_price,
maker_fee, taker_fee, maker_commission, taker_commission FROM market
WHERE broker_id = '%s' AND market_id = '%s'""" % (
mi[1], mi[2]))
row = cursor.fetchone()
if row:
market_info = Market(mi[2], row[0])
market_info.is_open = True
market_info.market_type = row[1]
market_info.unit_type = row[2]
market_info.contract_type = row[3]
market_info.trade = row[4]
market_info.orders = row[5]
market_info.set_base(row[6], row[7], int(row[8]))
market_info.set_quote(row[9], row[10], int(row[11]))
market_info.expiry = row[12]
market_info.last_update_time = row[13] * 0.001
market_info.lot_size = float(row[14])
market_info.contract_size = float(row[15])
market_info.base_exchange_rate = float(row[16])
market_info.value_per_pip = float(row[17])
market_info.one_pip_means = float(row[18])
if row[19] is not None or row[19] is not 'None':
if row[19] == '-': # not defined mean 1.0 or no margin
market_info.margin_factor = 1.0
else:
market_info.margin_factor = float(row[19] or "1.0")
market_info.set_size_limits(float(row[20]), float(row[21]), float(row[22]))
market_info.set_notional_limits(float(row[23]), float(row[24]), float(row[25]))
market_info.set_price_limits(float(row[26]), float(row[27]), float(row[28]))
market_info.maker_fee = float(row[29])
market_info.taker_fee = float(row[30])
market_info.maker_commission = float(row[31])
market_info.taker_commission = float(row[32])
else:
market_info = None
# notify
mi[0].notify(Signal.SIGNAL_MARKET_INFO_DATA, mi[1], (mi[2], market_info))
except self.psycopg2.OperationalError as e:
self.try_reconnect(e)
# retry the next time
with self._mutex:
self._pending_market_info_select = mis + self._pending_market_info_select
except Exception as e:
self.on_error(e)
# retry the next time
with self._mutex:
self._pending_market_info_select = mis + self._pending_market_info_select
#
# select market list
#
with self._mutex:
mls = self._pending_market_list_select
self._pending_market_list_select = []
if mls:
try:
cursor = self._db.cursor()
for m in mls:
cursor.execute("""SELECT market_id, symbol, base, quote FROM market WHERE broker_id = '%s'""" % (m[1],))
rows = cursor.fetchall()
market_list = []
for row in rows:
market_list.append(row)
# notify
m[0].notify(Signal.SIGNAL_MARKET_LIST_DATA, m[1], market_list)
except self.psycopg2.OperationalError as e:
self.try_reconnect(e)
# retry the next time
with self._mutex:
self._pending_market_list_select = mls + self._pending_market_list_select
except Exception as e:
self.on_error(e)
# retry the next time
with self._mutex:
self._pending_market_list_select = mls + self._pending_market_list_select
