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")