def on_query_contract(self):
""""""
#print('started checking and saving data, it might take a few minutes')
contract = ContractData(symbol='510050',
exchange=Exchange.SSE,
name='50ETF',
product=Product.ETF,
size=10000,
pricetick=1 / 100,
min_volume=1,
gateway_name=self.gateway_name)
self.on_contract(contract)
for con in sinaopapi.get_op_contracts('510050'):
contract = ContractData(
symbol=con['symbol'],
exchange=Exchange.SSE,
name=con['name'],
product=Product.OPTION,
size=10000,
pricetick=1 / 10000,
min_volume=1,
gateway_name=self.gateway_name,
option_strike=float(con['option_strike']),
option_underlying=con[
'option_underlying'], # vt_symbol of underlying contract
option_type=con['option_type'],
option_expiry=datetime.strptime(con["option_expiry"],
"%Y-%m-%d"))
self.on_contract(contract)
print(
f'"{contract.symbol}.SSE": {{"symbol": "{contract.symbol}", "exchange": "SSE","gateway_name": "WEBOPTION"}},'
)
self.write_log("合约查询成功")
def on_login(self, data: List[Dict[str, str]]) -> None:
""""""
if not data:
self.gateway.write_log("交易服务器登录失败")
return
else:
self.gateway.write_log("交易服务器登录成功")
self.login_status = True
for d in data:
self.user_token = d["user_token"]
self.branch_no = d["branch_no"]
self.client_id = d["client_id"]
self.asset_prop = d["asset_prop"]
self.sysnode_id = d["sysnode_id"]
# Generate ETF contract data
contract_1 = ContractData(
symbol="510050",
exchange=Exchange.SSE,
name="50ETF",
size=1,
pricetick=0.001,
product=Product.ETF,
gateway_name=self.gateway_name
)
self.gateway.on_contract(contract_1)
contract_2 = ContractData(
symbol="510300",
exchange=Exchange.SSE,
name="300ETF",
size=1,
pricetick=0.001,
product=Product.ETF,
gateway_name=self.gateway_name
)
self.gateway.on_contract(contract_2)
contract_3 = ContractData(
symbol="159919",
exchange=Exchange.SZSE,
name="300ETF",
size=1,
pricetick=0.001,
product=Product.ETF,
gateway_name=self.gateway_name
)
self.gateway.on_contract(contract_3)
self.query_contract()
def query_contract(self):
for category in self.api.Contracts.Futures:
for contract in category:
data = ContractData(
symbol=contract.code,
exchange=Exchange.TFE,
name=contract.name + contract.delivery_month,
product=Product.FUTURES,
size=200,
pricetick=contract.unit,
net_position=True,
min_volume=1,
gateway_name=self.gateway_name
)
self.on_contract(data)
self.code2contract[contract.code] = contract
for category in self.api.Contracts.Options:
for contract in category:
data = ContractData(
symbol=contract.code,
exchange=Exchange.TFE,
name=contract.name + contract.delivery_month,
product=Product.OPTION,
size=50,
net_position=True,
pricetick=contract.unit,
min_volume=1,
gateway_name=self.gateway_name,
option_strike=contract.strike_price,
option_underlying=contract.underlying_code,
option_type=OptionType.CALL if contract.option_right == "C" else OptionType.PUT,
option_expiry=None
)
self.on_contract(data)
self.code2contract[contract.code] = contract
for category in self.api.Contracts.Stocks:
for contract in category:
data = ContractData(
symbol=contract.code,
exchange=Exchange.TSE,
name=contract.name,
product=Product.EQUITY,
size=1,
net_position=False,
pricetick=contract.unit,
min_volume=1,
gateway_name=self.gateway_name
)
self.on_contract(data)
self.code2contract[contract.code] = contract
def on_query_contract(self, data: dict, request: Request) -> None:
""""""
for d in data["symbols"]:
base_currency = d["baseAsset"]
quote_currency = d["quoteAsset"]
name = f"{base_currency.upper()}/{quote_currency.upper()}"
pricetick = 1
min_volume = 1
for f in d["filters"]:
if f["filterType"] == "PRICE_FILTER":
pricetick = float(f["tickSize"])
elif f["filterType"] == "LOT_SIZE":
min_volume = float(f["stepSize"])
contract = ContractData(
symbol=d["symbol"],
exchange=Exchange.BINANCE,
name=name,
pricetick=pricetick,
size=1,
min_volume=min_volume,
product=Product.FUTURES,
net_position=True,
history_data=True,
gateway_name=self.gateway_name,
)
self.gateway.on_contract(contract)
symbol_contract_map[contract.symbol] = contract
self.gateway.write_log("合约信息查询成功")
def on_query_contract(self, data, request):
"""查询合约的回调函数"""
for instrument_data in data:
symbol = instrument_data["instrument_id"]
contract = ContractData(
symbol=symbol,
exchange=Exchange.OKEX,
name=symbol,
product=Product.SPOT,
size=1,
pricetick=float(instrument_data["tick_size"]),
min_volume=float(instrument_data["min_size"]),
gateway_name=self.gateway_name)
# 查询之后，推送合约
self.gateway.on_contract(contract)
# 添加合约
instruments.add(instrument_data["instrument_id"])
# 添加交易货币币种
currencies.add(instrument_data["base_currency"])
# 添加计价货币币种
currencies.add(instrument_data["quote_currency"])
self.gateway.write_log("合约信息查询成功")
# Start websocket api after instruments data collected
# 这里的设计，当查询完合约之后，要启动websocket api
self.gateway.ws_api.start()
# 查询合约之后，查询未成交订单
self.query_order()
def query_contract(self):
""""""
for product, futu_product in PRODUCT_VT2FUTU.items():
code, data = self.quote_ctx.get_stock_basicinfo(
self.market, futu_product)
if code:
self.write_log(f"查询合约信息失败：{data}")
return
for ix, row in data.iterrows():
symbol, exchange = convert_symbol_futu2vt(row["code"])
contract = ContractData(
symbol=symbol,
exchange=exchange,
name=row["name"],
product=product,
size=1,
pricetick=0.001,
net_position=True,
gateway_name=self.gateway_name,
)
self.on_contract(contract)
self.contracts[contract.vt_symbol] = contract
self.write_log("合约信息查询成功")
def contractDetails(self, reqId: int, contractDetails: ContractDetails): # pylint: disable=invalid-name
"""
Callback of contract data update.
"""
super(IbApi, self).contractDetails(reqId, contractDetails)
ib_symbol = contractDetails.contract.conId
ib_exchange = contractDetails.contract.exchange
ib_size = contractDetails.contract.multiplier
ib_product = contractDetails.contract.secType
if not ib_size:
ib_size = 1
contract = ContractData(
symbol=ib_symbol,
exchange=EXCHANGE_IB2VT.get(ib_exchange, ib_exchange),
name=contractDetails.longName,
product=PRODUCT_IB2VT[ib_product],
size=ib_size,
pricetick=contractDetails.minTick,
net_position=True,
history_data=True,
stop_supported=True,
gateway_name=self.gateway_name,
)
if contract.vt_symbol not in self.contracts:
self.gateway.on_contract(contract)
self.contracts[contract.vt_symbol] = contract
def on_query_contract(self, data, request): # type: (dict, Request)->None
""""""
if self.check_error(data, "查询合约"):
return
for d in data["data"]:
self.currencies.add(d["symbol"])
contract = ContractData(
symbol=d["contract_code"],
exchange=Exchange.HUOBI,
name=d["contract_code"],
pricetick=d["price_tick"],
size=int(d["contract_size"]),
min_volume=1,
product=Product.FUTURES,
history_data=True,
gateway_name=self.gateway_name,
)
self.gateway.on_contract(contract)
symbol_type_map[contract.symbol] = d["contract_type"]
self.gateway.write_log("合约信息查询成功")
self.query_order()
def onQueryAllTickers(self, data: dict, error: dict, last: bool) -> None:
""""""
contract = ContractData(symbol=data["ticker"],
exchange=EXCHANGE_XTP2VT[data["exchange_id"]],
name=data["ticker_name"],
product=PRODUCT_XTP2VT[data["ticker_type"]],
size=1,
pricetick=data["price_tick"],
min_volume=data["buy_qty_unit"],
gateway_name=self.gateway_name)
if contract.product != Product.OPTION:
self.gateway.on_contract(contract)
symbol_name_map[contract.vt_symbol] = contract.name
if last:
self.gateway.write_log(f"{contract.exchange.value}合约信息查询成功")
if contract.exchange == Exchange.SSE:
self.sse_inited = True
else:
self.szse_inited = True
if self.sse_inited and self.szse_inited:
self.gateway.td_api.query_option_info()
def on_query_instrument(self, packet: dict):
""""""
currency = self.reqid_currency_map[packet["id"]]
for d in packet["result"]:
contract = ContractData(
symbol=d["instrument_name"],
exchange=Exchange.DERIBIT,
name=d["instrument_name"],
product=PRODUCT_DERIBIT2VT[d["kind"]],
pricetick=d["tick_size"],
size=d["contract_size"],
min_volume=d["min_trade_amount"],
net_position=True,
history_data=False,
gateway_name=self.gateway_name,
)
if contract.product == Product.OPTION:
contract.option_portfolio = d["base_currency"]
contract.option_strike = d["strike"]
contract.option_index = str(d["strike"])
contract.option_underlying = d["base_currency"]
contract.option_type = OPTIONTYPE_DERIBIT2VT[d["option_type"]]
contract.option_expiry = datetime.fromtimestamp(
d["expiration_timestamp"] / 1000)
self.gateway.on_contract(contract)
self.gateway.write_log(f"{currency}合约信息查询成功")
def on_query_contract(self, data, request):
""""""
for d in data["symbols"]:
base_currency = d["baseAsset"]
quote_currency = d["quoteAsset"]
name = f"{base_currency.upper()}/{quote_currency.upper()}"
pricetick = 0
min_volume = 0
for f in d["filters"]:
if f["filterType"] == "PRICE_FILTER":
pricetick = f["tickSize"]
elif f["filterType"] == "LOT_SIZE":
min_volume = f["stepSize"]
contract = ContractData(
symbol=d["symbol"],
exchange=Exchange.BINANCE,
name=name,
pricetick=pricetick,
size=1,
min_volume=min_volume,
product=Product.SPOT,
gateway_name=self.gateway_name,
)
self.gateway.on_contract(contract)
symbol_name_map[contract.symbol] = contract.name
self.gateway.write_log("合约信息查询成功")
def onRspSOPQryContactInfo(self, data: dict, error: dict,
last: bool) -> None:
""""""
if not data:
return
contract = ContractData(
symbol=data["securityOptionID"],
exchange=EXCHANGE_SEC2VT[data["exchangeID"]],
name=data["contractName"],
size=data["contactUnit"],
pricetick=data["miniPriceChange"],
product=Product.OPTION,
option_portfolio=data["securityID"] + "_O",
option_type=OPTION_TYPE_SEC2VT[data["optType"]],
option_strike=data["execPrice"],
option_underlying="-".join(
[data["securityID"],
str(data["endDate"])[:-2]]),
option_expiry=datetime.strptime(str(data["endDate"]), "%Y%m%d"),
gateway_name=self.gateway_name)
contract.option_index = get_option_index(contract.option_strike,
data["contractID"])
self.gateway.on_contract(contract)
if last:
msg = "期权交易合约信息获取完成"
self.gateway.write_log(msg)
def OnRspQrySecurity(
self,
data: dict,
error: dict,
reqid: int,
last: bool
) -> None:
"""
Callback of instrument query.
"""
if last:
self.gateway.write_log("合约信息查询成功")
if not data:
return
contract_data = ContractData(
gateway_name=self.gateway.gateway_name,
symbol=data["SecurityID"],
exchange=EXCHANGE_TORA2VT[bytes.decode(data["ExchangeID"])],
name=data["SecurityName"],
product=PRODUCT_TORA2VT[bytes.decode(data["ProductID"])],
size=data["VolumeMultiple"],
pricetick=data["PriceTick"],
min_volume=data["MinLimitOrderBuyVolume"],
stop_supported=False,
net_position=True,
history_data=False,
)
self.gateway.on_contract(contract_data)
def onQueryOption(self, data: dict, head: dict, reqid: int) -> None:
""""""
last = head["isEnd"]
contract = ContractData(
symbol=data["securityId"],
exchange=EXCHANGE_OES2VT[data["mktId"]],
product=PRODUCT_OES2VT[data["securityType"]],
size=1,
min_volume=data["buyQtyUnit"],
name=data["securityName"],
pricetick=data["priceTick"] / 10000,
option_strike=data["exercisePrice"] / 10000,
option_underlying=data["underlyingSecurityId"],
option_type=OPTIONTYPE_OES2VT[data["contractType"]],
option_expiry=datetime.strptime(str(data["lastTradeDay"]),
"%Y%m%d"),
gateway_name=self.gateway_name)
contract.option_index = get_option_index(contract.option_strike,
data["contractId"])
SYMBOL_PRODCUT_MAP[contract.vt_symbol] = contract.product
SYMBOL_NAME_MAP[contract.vt_symbol] = contract.name
SYMBOL_PRICETICK_MAP[contract.vt_symbol] = contract.pricetick
self.gateway.on_contract(contract)
if last:
self.gateway.write_log("期权合约查询完成")
def on_query_contract(self, data: dict, request: Request) -> None:
""""""
if self.check_error("查询合约", data):
return
for d in data["result"]:
symbol = d.get("name", d.get("symbol"))
self.contract_codes.add(symbol)
contract = ContractData(
symbol=symbol,
exchange=Exchange.BYBIT,
name=symbol,
product=Product.FUTURES,
size=1,
pricetick=float(d["price_filter"]["tick_size"]),
min_volume=d["lot_size_filter"]["min_trading_qty"],
net_position=True,
history_data=True,
gateway_name=self.gateway_name)
if self.usdt_base and "USDT" in contract.symbol:
self.gateway.on_contract(contract)
elif not self.usdt_base and "USDT" not in contract.symbol:
self.gateway.on_contract(contract)
self.gateway.write_log("合约信息查询成功")
self.query_position()
self.query_account()
def on_query_contract(self, data: dict, request: Request) -> None:
""""""
if self.check_error("查询合约", data):
return
for d in data["result"]:
# print("on query contract", d)
self.contract_codes.add(d["name"])
contract = ContractData(
symbol=d["name"],
exchange=Exchange.BYBIT,
name=d["name"],
product=Product.FUTURES,
size=1,
pricetick=float(d["price_filter"]["tick_size"]),
min_volume=d["lot_size_filter"]["min_trading_qty"],
net_position=True,
history_data=True,
gateway_name=self.gateway_name)
self.gateway.on_contract(contract)
self.gateway.write_log("合约信息查询成功")
self.query_position()
self.query_account()
def query_contract(self) -> None:
""""""
mt5_req = {"type": FUNCTION_QUERYCONTRACT}
packet = self.client.send_request(mt5_req)
if packet:
self.write_log("MT5连接成功")
for d in packet["data"]:
contract = ContractData(
symbol=d["symbol"].replace('.', '-'),
exchange=Exchange.OTC,
name=d["symbol"].replace('.', '-'),
product=Product.FOREX,
size=d["lot_size"],
pricetick=pow(10, -d["digits"]),
min_volume=d["min_lot"],
net_position=True,
stop_supported=True,
history_data=True,
gateway_name=self.gateway_name,
)
self.on_contract(contract)
self.write_log("合约信息查询成功")
def OnRspQrySecurity(self, info: CTORATstpSecurityField,
error_info: CTORATstpRspInfoField, request_id: int,
is_last: bool) -> None:
""""""
if is_last:
self.gateway.write_log(" contract information inquiry succeed ")
if not info:
return
if info.ProductID not in PRODUCT_TORA2VT:
return
if info.ExchangeID not in EXCHANGE_TORA2VT:
return
contract_data = ContractData(
gateway_name=self.gateway.gateway_name,
symbol=info.SecurityID,
exchange=EXCHANGE_TORA2VT[info.ExchangeID],
name=info.SecurityName,
product=PRODUCT_TORA2VT[info.ProductID],
size=info.VolumeMultiple, # to verify
pricetick=info.PriceTick,
min_volume=info.MinLimitOrderBuyVolume, # verify: buy?sell
stop_supported=False,
net_position=True,
history_data=False,
)
self.gateway.on_contract(contract_data)
def onQueryOptionAuctionInfo(self, data: dict, error: dict, reqid: int,
last: bool, session: int) -> None:
""""""
if not data or not data["ticker"]:
return
contract = ContractData(
symbol=data["ticker"],
exchange=MARKET_XTP2VT[data["security_id_source"]],
name=data["symbol"],
product=Product.OPTION,
size=data["contract_unit"],
min_volume=data["qty_unit"],
pricetick=data["price_tick"],
gateway_name=self.gateway_name)
contract.option_portfolio = data["underlying_security_id"] + "_O"
contract.option_underlying = (data["underlying_security_id"] + "-" +
str(data["delivery_month"]))
contract.option_type = OPTIONTYPE_XTP2VT.get(data["call_or_put"], None)
contract.option_strike = data["exercise_price"]
contract.option_index = str(data["exercise_price"])
contract.option_expiry = datetime.strptime(str(data["delivery_day"]),
"%Y%m%d")
contract.option_index = get_option_index(contract.option_strike,
data["contract_id"])
self.gateway.on_contract(contract)
if last:
self.gateway.write_log("期权信息查询成功")
def on_query_contract(self, data, request):
""""""
for instrument_data in data:
symbol = instrument_data["instrument_id"]
contract = ContractData(
symbol=symbol,
exchange=Exchange.OKEX,
name=symbol,
product=Product.SPOT,
size=1,
pricetick=float(instrument_data["tick_size"]),
min_volume=float(instrument_data["min_size"]),
history_data=True,
net_position=True,
gateway_name=self.gateway_name)
self.gateway.on_contract(contract)
instruments.add(instrument_data["instrument_id"])
currencies.add(instrument_data["base_currency"])
currencies.add(instrument_data["quote_currency"])
self.gateway.write_log("合约信息查询成功")
# Start websocket api after instruments data collected
self.gateway.ws_api.start()
def onRspQryInstrument(self, data: dict, error: dict, reqid: int,
last: bool):
"""
Callback of instrument query.
"""
product = PRODUCT_DA2VT.get(data["CommodityType"], None)
if product:
contract = ContractData(
symbol=data["CommodityCode"],
exchange=EXCHANGE_DA2VT[data["ExchangeNo"]],
name=data["ContractFName"],
product=product,
size=data["ProductDot"] / data["UpperTick"],
pricetick=data["UpperTick"],
gateway_name=self.gateway_name)
if product == Product.OPTION:
contract.option_type = OPTIONTYPE_DA2VT[data["OptionType"]]
contract.option_strike = to_float(data["OptionStrikePrice"])
contract.option_expiry = datetime.strptime(
data["LastTradeDay"], "%Y%m%d")
symbol_name_map[contract.vt_symbol] = contract.name
symbol_currency_map[contract.symbol] = data["CommodityFCurrencyNo"]
self.gateway.on_contract(contract)
if last:
self.gateway.write_log("合约信息查询成功")
def on_query_contract(self, data: List, request: Request) -> None:
""""""
if not data:
return
for instrument_data in data:
symbol = instrument_data["instrument_id"]
contract = ContractData(
symbol=symbol,
exchange=Exchange.OKEX,
name=symbol,
product=Product.OPTION,
size=float(instrument_data["lot_size"]),
pricetick=float(instrument_data["tick_size"]),
option_strike=int(instrument_data["strike"]),
option_underlying=instrument_data["underlying"],
option_type=instrument_data["option_type"],
option_expiry=datetime.strptime(instrument_data["delivery"],
"%Y-%m-%dT%H:%M:%S.%fZ"),
option_portfolio=instrument_data["underlying"] + "_O",
option_index=instrument_data["strike"],
history_data=True,
gateway_name=self.gateway_name,
)
self.gateway.on_contract(contract)
self.gateway.write_log("期权合约信息查询成功")
# Start websocket api after instruments data collected
self.gateway.ws_api.start()
# and query pending orders
self.query_account()
self.query_position()
self.query_order()
def onRspQryInstrument(self, data: dict, error: dict, reqid: int,
last: bool) -> None:
"""
Callback of instrument query.
"""
contract = ContractData(symbol=data["InstID"],
exchange=Exchange.SGE,
name=data["Name"],
product=Product.SPOT,
size=data["Unit"],
pricetick=data["Tick"],
gateway_name=self.gateway_name)
self.gateway.on_contract(contract)
symbol_exchange_map[contract.symbol] = contract.exchange
symbol_name_map[contract.symbol] = contract.name
symbol_size_map[contract.symbol] = contract.size
symbol_market_map[contract.symbol] = data["MarketID"]
if last:
self.gateway.write_log("合约信息查询成功")
for data in self.order_data:
self.onRtnOrder(data)
self.order_data.clear()
for data in self.trade_data:
self.onRtnTrade(data)
self.trade_data.clear()
def on_query_contract(self, data, request):
""""""
for instrument_data in data:
symbol = instrument_data["instrument_id"]
contract = ContractData(
symbol=symbol,
exchange=Exchange.OKEX,
name=symbol,
product=Product.FUTURES,
size=int(instrument_data["trade_increment"]),
pricetick=float(instrument_data["tick_size"]),
gateway_name=self.gateway_name,
)
self.gateway.on_contract(contract)
instruments.add(instrument_data["instrument_id"])
currencies.add(instrument_data["underlying_index"])
currencies.add(instrument_data["quote_currency"])
self.gateway.write_log("OKEX 合约 合约信息查询成功")
# Start websocket api after instruments data collected
self.gateway.ws_api.start()
# and query pending orders
self.query_order()
def on_query_contract(self, data: dict, request: Request) -> None:
""""""
if self.check_error(data, "查询合约"):
return
for d in data["data"]:
base_currency = d["base-currency"]
quote_currency = d["quote-currency"]
name = f"{base_currency.upper()}/{quote_currency.upper()}"
pricetick = 1 / pow(10, d["price-precision"])
min_volume = 1 / pow(10, d["amount-precision"])
contract = ContractData(
symbol=d["symbol"],
exchange=Exchange.HUOBI,
name=name,
pricetick=pricetick,
size=1,
min_volume=min_volume,
product=Product.SPOT,
history_data=True,
gateway_name=self.gateway_name,
)
self.gateway.on_contract(contract)
symbol_contract_map[contract.symbol] = contract
self.gateway.write_log("合约信息查询成功")
def on_query_contract(self, data: dict, request: Request) -> None:
""""""
if self.check_error(data, "查询合约"):
return
for d in data["data"]:
# Only allow cross margin contract
if not self.usdt_base or d["support_margin_mode"] != "isolated":
self.contract_codes.add(d["contract_code"])
contract = ContractData(
symbol=d["contract_code"],
exchange=Exchange.HUOBI,
name=d["contract_code"],
pricetick=d["price_tick"],
size=d["contract_size"],
min_volume=1,
product=Product.FUTURES,
history_data=True,
gateway_name=self.gateway_name,
)
self.gateway.on_contract(contract)
self.gateway.write_log("合约信息查询成功")
# Start querying open order info
self.order_codes = copy(self.contract_codes)
contract_code = self.order_codes.pop()
self.query_order(contract_code)
def contractDetails(self, reqId: int, contractDetails: ContractDetails): # pylint: disable=invalid-name
"""
Callback of contract data update.
"""
super().contractDetails(reqId, contractDetails)
# Generate symbol from ib contract details
ib_contract = contractDetails.contract
if not ib_contract.multiplier:
ib_contract.multiplier = 1
symbol = generate_symbol(ib_contract)
# Generate contract
contract = ContractData(
symbol=symbol,
exchange=EXCHANGE_IB2VT[ib_contract.exchange],
name=contractDetails.longName,
product=PRODUCT_IB2VT[ib_contract.secType],
size=ib_contract.multiplier,
pricetick=contractDetails.minTick,
net_position=True,
history_data=True,
stop_supported=True,
gateway_name=self.gateway_name,
)
if contract.vt_symbol not in self.contracts:
self.gateway.on_contract(contract)
self.contracts[contract.vt_symbol] = contract
self.save_contract_data()
def on_query_contract(self, data, request): # type: (dict, Request)->None
""""""
if self.check_error(data, " query contract "):
return
for d in data["data"]:
base_currency = d["base-currency"]
quote_currency = d["quote-currency"]
name = f"{base_currency.upper()}/{quote_currency.upper()}"
pricetick = 1 / pow(10, d["price-precision"])
min_volume = 1 / pow(10, d["amount-precision"])
contract = ContractData(
symbol=d["symbol"],
exchange=Exchange.HUOBI,
name=name,
pricetick=pricetick,
size=1,
min_volume=min_volume,
product=Product.SPOT,
gateway_name=self.gateway_name,
)
self.gateway.on_contract(contract)
huobi_symbols.add(contract.symbol)
symbol_name_map[contract.symbol] = contract.name
self.gateway.write_log(" contract information inquiry succeed ")
def on_query_contracts(self, data, request):
""""""
for instrument_data in data:
symbol = instrument_data["instrument_id"]
contract = ContractData(
symbol=symbol,
exchange=Exchange.OKEX,
name=symbol,
product=Product.FUTURES,
size=float(instrument_data["contract_val"]),
pricetick=float(instrument_data["tick_size"]),
history_data=True,
gateway_name=self.gateway_name,
)
self.gateway.on_contract(contract)
instruments.add(instrument_data["instrument_id"])
self.gateway.write_log("合约信息查询成功")
# Start websocket api after instruments data collected
self.gateway.ws_api.start()
# and query pending orders
self.query_orders()
def on_query_contract(self, data, request):
""""""
for d in data:
pricetick = 1 / pow(10, d["counter_decimals"])
min_volume = 1 / pow(10, d["base_decimals"])
contract = ContractData(
symbol=d["url_symbol"],
exchange=Exchange.BITSTAMP,
name=d["name"],
product=Product.SPOT,
size=1,
pricetick=pricetick,
min_volume=min_volume,
history_data=True,
gateway_name=self.gateway_name,
)
self.gateway.on_contract(contract)
symbol_name_map[contract.symbol] = contract.name
name_symbol_map[contract.name] = contract.symbol
self.gateway.write_log("合约信息查询成功")
self.query_order()