def put_position(self): if FH.forward_leverage != FH.forward_gap_level: forward_api_instance.update_position_leverage(contract=FH.contract,settle=FH.settle,leverage = FH.forward_gap_level) FH.forward_leverage = FH.forward_gap_level if FH.backward_leverage != FH.backward_gap_level: backward_api_instance.update_position_leverage(contract=FH.contract,settle=FH.settle,leverage = FH.backward_gap_level) FH.backward_leverage = FH.backward_gap_level self.forward_increase_clear = False self.forward_reduce_clear = False for order in FH.forward_orders: order_price = float(order._price) order_size = order._size order_id = order._id if order_size > 0: self.forward_increase_clear = True elif order_size < 0: self.forward_reduce_clear = True if order_size > 0: if (not self.forward_catch) or FH.forward_position_size >= FH.forward_limit: forward_api_instance.cancel_futures_order(settle=FH.settle,order_id=order_id) elif self.forward_catch and self.forward_catch_size <= 0: forward_api_instance.cancel_futures_order(settle=FH.settle,order_id=order_id) elif FH.bid_1 > order_price: forward_api_instance.cancel_futures_order(settle=FH.settle,order_id=order_id) elif order_size < 0: if self.forward_gap_balance: if order_price > FH.ask_1 or self.forward_balance_size >= 0: forward_api_instance.cancel_futures_order(settle=FH.settle,order_id=order_id) else: forward_api_instance.cancel_futures_order(settle=FH.settle,order_id=order_id) if not self.forward_increase_clear: if FH.forward_position_size < FH.forward_limit: if self.forward_catch and self.forward_catch_size > 0: forward_api_instance.create_futures_order(settle=FH.settle,futures_order=FuturesOrder(contract=FH.contract,size = self.forward_catch_size, price = FH.bid_1,tif='poc')) if not self.forward_reduce_clear and self.forward_gap_balance: if FH.forward_position_size > 0: if self.forward_balance_size < 0: forward_api_instance.create_futures_order(settle=FH.settle,futures_order=FuturesOrder(contract=FH.contract,size=self.forward_balance_size,price = FH.ask_1,tif='poc')) self.backward_increase_clear = False self.backward_reduce_clear = False for order in FH.backward_orders: order_price = float(order._price) order_size = order._size order_id = order._id if order_size < 0: self.backward_increase_clear = True elif order_size > 0: self.backward_reduce_clear = True if order_size < 0: if (not self.backward_catch) or abs(FH.backward_position_size) >= FH.backward_limit: backward_api_instance.cancel_futures_order(settle=FH.settle,order_id=order_id) elif self.backward_catch and self.backward_catch_size >= 0: backward_api_instance.cancel_futures_order(settle=FH.settle,order_id=order_id) elif FH.ask_1 < order_price: backward_api_instance.cancel_futures_order(settle=FH.settle,order_id=order_id) elif order_size > 0: if self.backward_gap_balance: if order_price < FH.bid_1 or self.backward_balance_size <= 0: backward_api_instance.cancel_futures_order(settle=FH.settle,order_id=order_id) else: backward_api_instance.cancel_futures_order(settle=FH.settle,order_id=order_id) if not self.backward_increase_clear: if abs(FH.backward_position_size) < FH.backward_limit: if self.backward_catch and self.backward_catch_size < 0: backward_api_instance.create_futures_order(settle=FH.settle,futures_order=FuturesOrder(contract=FH.contract,size = self.backward_catch_size, price = FH.ask_1,tif='poc')) if not self.backward_reduce_clear and self.backward_gap_balance: if FH.backward_position_size < 0: if self.backward_balance_size > 0: backward_api_instance.create_futures_order(settle=FH.settle,futures_order=FuturesOrder(contract=FH.contract,size=self.backward_balance_size,price = FH.bid_1,tif='poc')) if FH.forward_liq_flag: forward_api_instance.cancel_price_triggered_order_list(contract=FH.contract,settle=FH.settle) if FH.forward_liq_price > 0: forward_api_instance.create_price_triggered_order(settle=FH.settle,futures_price_triggered_order=FuturesPriceTriggeredOrder(initial=FuturesInitialOrder(contract=FH.contract,size=0,price=str(0),close=True,tif='ioc',text='api'),trigger=FuturesPriceTrigger(strategy_type=0,price_type=1,rule=2,price=str(round(FH.forward_liq_price*(1.0+0.1*1.0/FH.forward_leverage),FH.quanto)),expiration=2592000))) FH.forward_trigger_liq = FH.forward_liq_price*(1.0+0.1*1.0/FH.forward_leverage) if FH.backward_liq_flag: backward_api_instance.cancel_price_triggered_order_list(contract=FH.contract,settle=FH.settle) if FH.backward_liq_price > 0: backward_api_instance.create_price_triggered_order(settle=FH.settle,futures_price_triggered_order=FuturesPriceTriggeredOrder(initial=FuturesInitialOrder(contract=FH.contract,size=0,price=str(0),close=True,tif='ioc',text='api'),trigger=FuturesPriceTrigger(strategy_type=0,price_type=1,rule=1,price=str(round(FH.backward_liq_price*(1.0-0.1*1.0/FH.backward_leverage),FH.quanto)),expiration=2592000))) FH.backward_trigger_liq = FH.backward_liq_price*(1.0-0.1*1.0/FH.backward_leverage)
def put_position(self): if FH.forward_leverage != FH.forward_gap_level: forward_api_instance.update_position_leverage( contract=FH.contract, settle=FH.settle, leverage=FH.forward_gap_level) FH.forward_leverage = FH.forward_gap_level if FH.backward_leverage != FH.backward_gap_level: backward_api_instance.update_position_leverage( contract=FH.contract, settle=FH.settle, leverage=FH.backward_gap_level) FH.backward_leverage = FH.backward_gap_level self.forward_increase_clear = False self.forward_reduce_clear = False for order in FH.forward_orders: order_price = float(order._price) order_size = order._size order_id = order._id if order_size > 0: self.forward_increase_clear = True elif order_size < 0: self.forward_reduce_clear = True if order_size > 0: if self.forward_catch: if FH.bid_1 > order_price: forward_api_instance.cancel_futures_order( settle=FH.settle, order_id=order_id) else: forward_api_instance.cancel_futures_order( settle=FH.settle, order_id=order_id) elif order_size < 0: if self.forward_gap_balance: if order_price > FH.ask_1: forward_api_instance.cancel_futures_order( settle=FH.settle, order_id=order_id) else: forward_api_instance.cancel_futures_order( settle=FH.settle, order_id=order_id) if not self.forward_increase_clear: if FH.forward_position_size < FH.forward_limit: if self.forward_catch and self.forward_catch_size > 0: forward_api_instance.create_futures_order( settle=FH.settle, futures_order=FuturesOrder( contract=FH.contract, size=self.forward_catch_size, price=FH.bid_1, tif='poc')) if not self.forward_reduce_clear and self.forward_gap_balance: if FH.forward_position_size > 0: if self.forward_balance_size > 0: forward_api_instance.create_futures_order( settle=FH.settle, futures_order=FuturesOrder( contract=FH.contract, size=-self.forward_balance_size, price=FH.ask_1, tif='poc')) self.backward_increase_clear = False self.backward_reduce_clear = False for order in FH.backward_orders: order_price = float(order._price) order_size = order._size order_id = order._id if order_size < 0: self.backward_increase_clear = True elif order_size > 0: self.backward_reduce_clear = True if order_size < 0: if self.backward_catch: if FH.ask_1 < order_price: backward_api_instance.cancel_futures_order( settle=FH.settle, order_id=order_id) else: backward_api_instance.cancel_futures_order( settle=FH.settle, order_id=order_id) elif order_size > 0: if self.backward_gap_balance: if order_price < FH.bid_1: backward_api_instance.cancel_futures_order( settle=FH.settle, order_id=order_id) else: backward_api_instance.cancel_futures_order( settle=FH.settle, order_id=order_id) if not self.backward_increase_clear: if FH.backward_position_size < FH.backward_limit: if self.backward_catch and self.backward_catch_size > 0: backward_api_instance.create_futures_order( settle=FH.settle, futures_order=FuturesOrder( contract=FH.contract, size=-self.backward_catch_size, price=FH.ask_1, tif='poc')) if not self.backward_reduce_clear and self.backward_gap_balance: if FH.backward_position_size > 0: if self.backward_balance_size > 0: backward_api_instance.create_futures_order( settle=FH.settle, futures_order=FuturesOrder( contract=FH.contract, size=self.backward_balance_size, price=FH.bid_1, tif='poc'))
def get_position(self, follow_signal, balance_signal): orders = api_instance.list_futures_orders(contract=self.contract, status='open', async_req=True) positions = api_instance.get_position(contract=self.contract, async_req=True) book = api_instance.list_futures_order_book(contract=self.contract, async_req=True) orders = orders.get() positions = positions.get() book = book.get() entry_price = float(positions._entry_price) mark_price = float(positions._mark_price) liq_price = float(positions._liq_price) position_size = positions._size self.position_size = position_size if position_size == 0: api_instance.update_position_leverage(contract=self.contract, leverage=self.leverage) ask_1 = float(book._asks[0]._p) bid_1 = float(book._bids[0]._p) if position_size > 0 and entry_price > 0: gap = (entry_price - ask_1) / entry_price elif position_size < 0 and entry_price > 0: gap = (bid_1 - entry_price) / entry_price else: gap = 0.0 duo_clear = False kong_clear = False bias = 1.0 / self.leverage * 0.2 if abs((mark_price - ask_1) / mark_price) > bias or abs( (mark_price - bid_1) / mark_price) > bias: return for order in orders: order_price = float(order._price) order_size = order._size order_id = order._id if order_size < 0: kong_clear = True elif order_size > 0: duo_clear = True if abs( position_size ) < self.minor_position * self.leverage and follow_signal and not balance_signal: if position_size < 0: if order_size < 0: if (order_price - ask_1) / ask_1 > self.follow: api_instance.cancel_futures_order(order_id) api_instance.create_futures_order( FuturesOrder(contract=self.contract, size=-self.tap * self.leverage, price=ask_1, tif='poc')) elif order_size > 0: if bid_1 > entry_price: api_instance.cancel_futures_order(order_id) elif bid_1 < entry_price and ( bid_1 - order_price) / bid_1 > self.balance: api_instance.cancel_futures_order(order_id) api_instance.create_futures_order( FuturesOrder(contract=self.contract, size=-position_size, price=bid_1, tif='poc')) elif position_size > 0: if order_size > 0: if (bid_1 - order_price) / bid_1 > self.follow: api_instance.cancel_futures_order(order_id) api_instance.create_futures_order( FuturesOrder(contract=self.contract, size=self.tap * self.leverage, price=bid_1, tif='poc')) elif order_size < 0: if ask_1 < entry_price: api_instance.cancel_futures_order(order_id) elif ask_1 > entry_price and ( order_price - ask_1) / ask_1 > self.balance: api_instance.cancel_futures_order(order_id) api_instance.create_futures_order( FuturesOrder(contract=self.contract, size=-position_size, price=ask_1, tif='poc')) elif position_size == 0: if order_size > 0: if (bid_1 - order_price) / bid_1 > self.follow: api_instance.cancel_futures_order(order_id) api_instance.create_futures_order( FuturesOrder(contract=self.contract, size=self.tap * self.leverage, price=bid_1, tif='poc')) elif order_size < 0: if (order_price - ask_1) / ask_1 > self.follow: api_instance.cancel_futures_order(order_id) api_instance.create_futures_order( FuturesOrder(contract=self.contract, size=-self.tap * self.leverage, price=ask_1, tif='poc')) elif abs( position_size ) < self.limit_position * self.leverage and not follow_signal and not balance_signal: if abs(gap) >= self.mayor_gap and abs( gap ) < self.limit_gap and abs( position_size ) * self.size_inc <= self.limit_position * self.leverage: if position_size < 0: if order_size < 0: if order_price > ask_1: api_instance.cancel_futures_order(order_id) api_instance.create_futures_order( FuturesOrder(contract=self.contract, size=position_size * self.size_inc, price=ask_1, tif='poc')) elif order_size > 0: if bid_1 < entry_price and ( bid_1 - order_price) / bid_1 > self.balance: api_instance.cancel_futures_order(order_id) api_instance.create_futures_order( FuturesOrder(contract=self.contract, size=-position_size, price=bid_1, tif='poc')) elif bid_1 > entry_price: api_instance.cancel_futures_order(order_id) elif position_size > 0: if order_size > 0: if order_price < bid_1: api_instance.cancel_futures_order(order_id) api_instance.create_futures_order( FuturesOrder(contract=self.contract, size=position_size * self.size_inc, price=bid_1, tif='poc')) elif order_size < 0: if ask_1 > entry_price and ( order_price - ask_1) / ask_1 > self.balance: api_instance.cancel_futures_order(order_id) api_instance.create_futures_order( FuturesOrder(contract=self.contract, size=-position_size, price=ask_1, tif='poc')) elif ask_1 < entry_price: api_instance.cancel_futures_order(order_id) elif abs(gap) < self.mayor_gap: if position_size < 0: if order_size > 0: if bid_1 < entry_price and ( bid_1 - order_price) / bid_1 > self.balance: api_instance.cancel_futures_order(order_id) api_instance.create_futures_order( FuturesOrder(contract=self.contract, size=-position_size, price=bid_1, tif='poc')) elif bid_1 > entry_price: api_instance.cancel_futures_order(order_id) elif position_size > 0: if order_size < 0: if ask_1 > entry_price and ( order_price - ask_1) / ask_1 > self.balance: api_instance.cancel_futures_order(order_id) api_instance.create_futures_order( FuturesOrder(contract=self.contract, size=-position_size, price=ask_1, tif='poc')) elif ask_1 < entry_price: api_instance.cancel_futures_order(order_id) if not duo_clear: if position_size < 0: if bid_1 < entry_price: api_instance.create_futures_order( FuturesOrder(contract=self.contract, size=-position_size, price=bid_1, tif='poc')) elif position_size > 0: if abs( position_size ) < self.minor_position * self.leverage and follow_signal and not balance_signal: api_instance.create_futures_order( FuturesOrder(contract=self.contract, size=self.tap * self.leverage, price=bid_1, tif='poc')) elif abs( position_size ) < self.limit_position * self.leverage and not follow_signal and not balance_signal: if abs(gap) >= self.mayor_gap and abs( gap ) < self.limit_gap and abs( position_size ) * self.size_inc <= self.limit_position * self.leverage: api_instance.create_futures_order( FuturesOrder(contract=self.contract, size=position_size * self.size_inc, price=bid_1, tif='poc')) elif position_size == 0: api_instance.create_futures_order( FuturesOrder(contract=self.contract, size=self.tap * self.leverage, price=bid_1, tif='poc')) if not kong_clear: if position_size > 0: if ask_1 > entry_price: api_instance.create_futures_order( FuturesOrder(contract=self.contract, size=-position_size, price=ask_1, tif='poc')) elif position_size < 0: if abs( position_size ) < self.minor_position * self.leverage and follow_signal and not balance_signal: api_instance.create_futures_order( FuturesOrder(contract=self.contract, size=-self.tap * self.leverage, price=ask_1, tif='poc')) elif abs( position_size ) < self.limit_position * self.leverage and not follow_signal and not balance_signal: if abs(gap) >= self.mayor_gap and abs( gap ) < self.limit_gap and abs( position_size ) * self.size_inc <= self.limit_position * self.leverage: api_instance.create_futures_order( FuturesOrder(contract=self.contract, size=position_size * self.size_inc, price=ask_1, tif='poc')) elif position_size == 0: api_instance.create_futures_order( FuturesOrder(contract=self.contract, size=-self.tap * self.leverage, price=ask_1, tif='poc'))
def cancel_position(self): orders = api_instance.list_futures_orders(contract=self.contract, status='open', async_req=True) positions = api_instance.get_position(contract=self.contract, async_req=True) book = api_instance.list_futures_order_book(contract=self.contract, async_req=True) orders = orders.get() positions = positions.get() book = book.get() entry_price = float(positions._entry_price) position_size = positions._size ask_1 = float(book._asks[0]._p) bid_1 = float(book._bids[0]._p) if position_size > 0 and entry_price > 0: gap = (entry_price - ask_1) / entry_price elif position_size < 0 and entry_price > 0: gap = (bid_1 - entry_price) / entry_price kong_clear = False duo_clear = False for order in orders: order_price = float(order._price) order_size = order._size order_id = order._id if order_size < 0: kong_clear = True elif order_size > 0: duo_clear = True if position_size > 0: if order_size > 0 and gap <= self.minor_gap: api_instance.cancel_futures_order(order_id) elif order_size < 0: if ask_1 < entry_price or order_price > ask_1: api_instance.cancel_futures_order(order_id) elif ask_1 >= entry_price and order_price > ask_1: api_instance.cancel_futures_order(order_id) api_instance.create_futures_order( FuturesOrder(contract=self.contract, size=-position_size, price=ask_1, tif='poc')) elif position_size < 0: if order_size < 0 and gap < self.minor_gap: api_instance.cancel_futures_order(order_id) elif order_size > 0: if bid_1 > entry_price or order_price < bid_1: api_instance.cancel_futures_order(order_id) elif bid_1 <= entry_price and order_price < bid_1: api_instance.cancel_futures_order(order_id) api_instance.create_futures_order( FuturesOrder(contract=self.contract, size=-position_size, price=bid_1, tif='poc')) if not duo_clear: if position_size < 0: if bid_1 <= entry_price: api_instance.create_futures_order( FuturesOrder(contract=self.contract, size=-position_size, price=bid_1, tif='poc')) if not kong_clear: if position_size > 0: if ask_1 >= entry_price: api_instance.create_futures_order( FuturesOrder(contract=self.contract, size=-position_size, price=ask_1, tif='poc'))
def futures_demo(run_config): # type: (RunConfig) -> None settle = "usdt" contract = "BTC_USDT" # Initialize API client # Setting host is optional. It defaults to https://api.gateio.ws/api/v4 config = Configuration(key=run_config.api_key, secret=run_config.api_secret, host=run_config.host_used) futures_api = FuturesApi(ApiClient(config)) # update position leverage leverage = "3" futures_api.update_position_leverage(settle, contract, leverage) # retrieve position size position_size = 0 try: position = futures_api.get_position(settle, contract) position_size = position.size except GateApiException as ex: if ex.label != "POSITION_NOT_FOUND": raise ex # set order size futures_contract = futures_api.get_futures_contract(settle, contract) order_size = 10 if futures_contract.order_size_min and futures_contract.order_size_min > order_size: order_size = futures_contract.order_size_min if position_size < 0: order_size = 0 - order_size # example to update risk limit assert futures_contract.risk_limit_base assert futures_contract.risk_limit_step risk_limit = D(futures_contract.risk_limit_base) + D( futures_contract.risk_limit_step) futures_api.update_position_risk_limit(settle, contract, str(risk_limit)) # retrieve last price to calculate margin needed tickers = futures_api.list_futures_tickers(settle, contract=contract) assert len(tickers) == 1 last_price = tickers[0].last logger.info("last price of contract %s: %s", contract, last_price) getcontext().prec = 8 getcontext().rounding = ROUND_UP assert futures_contract.quanto_multiplier margin = order_size * D(last_price) * D( futures_contract.quanto_multiplier) / D(leverage) * D("1.1") logger.info("needs margin amount: %s", str(margin)) # if balance is not enough, transfer from spot account available = "0" try: futures_account = futures_api.list_futures_accounts(settle) available = futures_account.available except GateApiException as ex: if ex.label != "USER_NOT_FOUND": raise ex logger.info("futures account available: %s %s", available, settle.upper()) if D(available) < margin: if run_config.use_test: logger.warning( "testnet account balance not enough. make a transferal on web") return transfer = Transfer(amount=str(margin), currency=settle.upper(), _from='spot', to='futures') wallet_api = WalletApi(ApiClient(config)) wallet_api.transfer(transfer) # example to cancel all open orders in contract futures_api.cancel_futures_orders(settle, contract) # order using market price order = FuturesOrder(contract=contract, size=order_size, price="0", tif='ioc') try: order_response = futures_api.create_futures_order(settle, order) except GateApiException as ex: logger.error("error encountered creating futures order: %s", ex) return logger.info("order %s created with status: %s", order_response.id, order_response.status) if order_response.status == 'open': futures_order = futures_api.get_futures_order(settle, str(order_response.id)) logger.info("order %s status %s, total size %s, left %s", futures_order.id, futures_order.status, futures_order.size, futures_order.left) futures_api.cancel_futures_order(settle, str(futures_order.id)) logger.info("order %s cancelled", futures_order.id) else: time.sleep(0.2) order_trades = futures_api.get_my_trades(settle, contract=contract, order=order_response.id) assert len(order_trades) > 0 trade_size = 0 for t in order_trades: assert t.order_id == str(order_response.id) trade_size += t.size logger.info("order %s filled size %s with price %s", t.order_id, t.size, t.price) assert trade_size == order_size # example to update position margin futures_api.update_position_margin(settle, contract, "0.01")