def send_order(self, req: OrderRequest):
""""""
req.offset = Offset.NONE
order_id = self._new_order_id()
symbol = req.symbol
vol = int(req.volume)
direction = req.direction
data = {
"instrument": symbol,
# positive for long , negative for short
"units": vol if direction is Direction.LONG else -vol,
"clientExtensions": {
"id": order_id,
}
}
order = req.create_order_data(order_id, self.gateway_name)
order.time = parse_time(datetime.now().isoformat())
# Only add price for limit order.
data["type"] = ORDER_TYPE_VT2OANDA[req.type]
data["price"] = str(req.price)
self.gateway.orders[order.orderid] = order
self.add_request(
"POST",
f"/v3/accounts/{self.gateway.account_id}/orders",
callback=self.on_send_order,
data={'order': data},
extra=order,
on_failed=self.on_send_order_failed,
on_error=self.on_send_order_error,
)
self.gateway.on_order(order)
return order.vt_orderid
def connect(
self,
key: str,
secret: str,
session_number: int,
proxy_host: str,
proxy_port: int,
):
"""
Initialize connection to REST server.
"""
self.key = key
self.secret = secret
self.connect_time = int(datetime.now().strftime("%y%m%d%H%M%S"))
self.init(REST_HOST_TRADE, proxy_host, proxy_port)
self.start(session_number)
self.gateway.write_log("ZB 交易 REST API 启动成功")
self.query_account()
# 指定要查询的交易对
self.query_order(symbol="usdt_qc")
# 测试接口
req = OrderRequest(symbol="usdt_qc", exchange=Exchange.ZB, direction=Direction.LONG, type=OrderType.LIMIT,
volume=0.01)
# 价格
req.price = 6.9
req.offset = Offset.NONE
self.send_order(req)
def send_order(self, req: OrderRequest):
""""""
# Offset is not supported for Comstar gateawy
req.offset = Offset.NONE
if req.type not in {OrderType.LIMIT, OrderType.FAK}:
self.write_log("仅支持限价单和FAK单")
return ""
symbol, settle_type, *_ = req.symbol.split("_") + [""]
if settle_type not in {"T0", "T1"}:
self.write_log("请输入清算速度T0或T1")
return ""
data = vn_encode(req)
data["symbol"] = symbol
data["settle_type"] = settle_type
data["strategy_name"] = data.pop("reference")
order_id = self.api.send_order(data, self.gateway_name)
# convert to vt_orderid
return f"{self.gateway_name}.{order_id}"
def run(self) -> None:
""""""
if not self.check_order_finished():
self.cancel_all()
return
delta_max = self.delta_target + self.delta_range
delta_min = self.delta_target - self.delta_range
# Do nothing if portfolio delta is in the allowed range
portfolio = self.option_engine.get_portfolio(self.portfolio_name)
if delta_min <= portfolio.pos_delta <= delta_max:
return
# Calculate volume of contract to hedge
delta_to_hedge = self.delta_target - portfolio.pos_delta
instrument = self.option_engine.get_instrument(self.vt_symbol)
hedge_volume = delta_to_hedge / instrument.theo_delta
# Send hedge orders
tick = self.main_engine.get_tick(self.vt_symbol)
contract = self.main_engine.get_contract(self.vt_symbol)
holding = self.option_engine.get_position_holding(self.vt_symbol)
if hedge_volume > 0:
price = tick.ask_price_1 + contract.pricetick * self.hedge_payup
direction = Direction.LONG
if holding:
available = holding.short_pos - holding.short_pos_frozen
else:
available = 0
else:
price = tick.bid_price_1 - contract.pricetick * self.hedge_payup
direction = Direction.SHORT
if holding:
available = holding.long_pos - holding.long_pos_frozen
else:
available = 0
order_volume = abs(hedge_volume)
req = OrderRequest(
symbol=contract.symbol,
exchange=contract.exchange,
direction=direction,
type=OrderType.LIMIT,
volume=order_volume,
price=round_to(price, contract.pricetick),
)
# Close positon if opposite available is enough
if available > order_volume:
req.offset = Offset.CLOSE
vt_orderid = self.main_engine.send_order(req,
contract.gateway_name)
self.active_orderids.add(vt_orderid)
# Open position if no oppsite available
elif not available:
req.offset = Offset.OPEN
vt_orderid = self.main_engine.send_order(req,
contract.gateway_name)
self.active_orderids.add(vt_orderid)
# Else close all opposite available and open left volume
else:
close_req = copy(req)
close_req.offset = Offset.CLOSE
close_req.volume = available
close_orderid = self.main_engine.send_order(
close_req, contract.gateway_name)
self.active_orderids.add(close_orderid)
open_req = copy(req)
open_req.offset = Offset.OPEN
open_req.volume = order_volume - available
open_orderid = self.main_engine.send_order(open_req,
contract.gateway_name)
self.active_orderids.add(open_orderid)
