def synchronize_orders(self):
bands = Bands.read(self.bands_config, self.spread_feed, self.history)
order_book = self.order_book_manager.get_order_book()
target_price = self.price_feed.get_price()
# Cancel orders
cancellable_orders = bands.cancellable_orders(our_buy_orders=self.our_buy_orders(order_book.orders),
our_sell_orders=self.our_sell_orders(order_book.orders),
target_price=target_price)
if len(cancellable_orders) > 0:
self.order_book_manager.cancel_orders(cancellable_orders)
return
# Do not place new orders if order book state is not confirmed
if order_book.orders_being_placed or order_book.orders_being_cancelled:
self.logger.debug("Order book is in progress, not placing new orders")
return
# In case of Paradex, balances returned by `our_total_balance` still contain amounts "locked"
# by currently open orders, so we need to explicitly subtract these amounts.
our_buy_balance = self.our_total_buy_balance(order_book.balances) - Bands.total_amount(self.our_buy_orders(order_book.orders))
our_sell_balance = self.our_total_sell_balance(order_book.balances) - Bands.total_amount(self.our_sell_orders(order_book.orders))
# Place new orders
self.place_orders(bands.new_orders(our_buy_orders=self.our_buy_orders(order_book.orders),
our_sell_orders=self.our_sell_orders(order_book.orders),
our_buy_balance=our_buy_balance,
our_sell_balance=our_sell_balance,
target_price=target_price)[0])
def synchronize_orders(self):
"""Update our positions in the order book to reflect keeper parameters."""
if eth_balance(self.web3, self.our_address) < self.min_eth_balance:
self.logger.warning("Keeper ETH balance below minimum. Cancelling all orders.")
self.cancel_orders(self.our_orders())
return
bands = Bands(self.bands_config, self.history)
our_orders = self.our_orders()
target_price = self.price_feed.get_price()
if target_price is None:
self.logger.warning("Cancelling all orders as no price feed available.")
self.cancel_orders(our_orders)
return
# Cancel orders
cancellable_orders = bands.cancellable_orders(our_buy_orders=self.our_buy_orders(our_orders),
our_sell_orders=self.our_sell_orders(our_orders),
target_price=target_price)
if len(cancellable_orders) > 0:
self.cancel_orders(cancellable_orders)
return
# Balances returned by `our_total_balance` still contain amounts "locked"
# by currently open orders, so we need to explicitly subtract these amounts.
our_buy_balance = self.our_total_balance(self.token_buy) - Bands.total_amount(self.our_buy_orders(our_orders))
our_sell_balance = self.our_total_balance(self.token_sell) - Bands.total_amount(self.our_sell_orders(our_orders))
# Place new orders
self.place_orders(bands.new_orders(our_buy_orders=self.our_buy_orders(our_orders),
our_sell_orders=self.our_sell_orders(our_orders),
our_buy_balance=our_buy_balance,
our_sell_balance=our_sell_balance,
target_price=target_price)[0])
def synchronize_orders(self):
if eth_balance(self.web3, self.our_address) < self.min_eth_balance:
self.logger.warning("Keeper ETH balance below minimum. Cancelling all orders.")
self.cancel_orders(self.our_orders())
return
bands = Bands(self.bands_config, self.spread_feed, self.history)
our_orders = self.our_orders()
target_price = self.price_feed.get_price()
# Cancel orders
cancellable_orders = bands.cancellable_orders(our_buy_orders=self.our_buy_orders(our_orders),
our_sell_orders=self.our_sell_orders(our_orders),
target_price=target_price)
if len(cancellable_orders) > 0:
self.cancel_orders(cancellable_orders)
return
# Balances returned by `our_total_balance` still contain amounts "locked"
# by currently open orders, so we need to explicitly subtract these amounts.
our_buy_balance = self.our_total_balance(self.token_buy) - Bands.total_amount(self.our_buy_orders(our_orders))
our_sell_balance = self.our_total_balance(self.token_sell) - Bands.total_amount(self.our_sell_orders(our_orders))
# Place new orders
self.place_orders(bands.new_orders(our_buy_orders=self.our_buy_orders(our_orders),
our_sell_orders=self.our_sell_orders(our_orders),
our_buy_balance=our_buy_balance,
our_sell_balance=our_sell_balance,
target_price=target_price)[0])
def synchronize_orders(self):
bands = Bands.read(self.bands_config, self.spread_feed,
self.control_feed, self.history)
order_book = self.order_book_manager.get_order_book()
target_price = self.price_feed.get_price()
# We filter out expired orders from the order book snapshot. The reason for that is that
# it allows us to replace expired orders faster. Without it, we would have to wait
# for the next order book refresh in order to realize an order has expired. Unfortunately,
# in case of 0x order book refresh can be quite slow as it involves making multiple calls
# to the Ethereum node.
#
# By filtering out expired orders here, we can replace them the next `synchronize_orders`
# tick after they expire. Which is ~ 1s delay, instead of avg ~ 5s without this trick.
orders = self.remove_expired_orders(order_book.orders)
if self.our_eth_balance(order_book.balances) < self.min_eth_balance:
self.logger.warning(
"Keeper ETH balance below minimum. Cancelling all orders.")
self.order_book_manager.cancel_all_orders()
return
# Cancel orders
cancellable_orders = bands.cancellable_orders(
our_buy_orders=self.our_buy_orders(orders),
our_sell_orders=self.our_sell_orders(orders),
target_price=target_price)
if len(cancellable_orders) > 0:
self.order_book_manager.cancel_orders(cancellable_orders)
return
# Do not place new orders if order book state is not confirmed
if order_book.orders_being_placed or order_book.orders_being_cancelled:
self.logger.debug(
"Order book is in progress, not placing new orders")
return
# Balances returned by `our_total_***_balance` still contain amounts "locked"
# by currently open orders, so we need to explicitly subtract these amounts.
if self.arguments.use_full_balances:
our_buy_balance = self.our_total_buy_balance(order_book.balances)
our_sell_balance = self.our_total_sell_balance(order_book.balances)
else:
our_buy_balance = self.our_total_buy_balance(
order_book.balances) - Bands.total_amount(
self.our_buy_orders(orders))
our_sell_balance = self.our_total_sell_balance(
order_book.balances) - Bands.total_amount(
self.our_sell_orders(orders))
# Place new orders
self.order_book_manager.place_orders(
bands.new_orders(our_buy_orders=self.our_buy_orders(orders),
our_sell_orders=self.our_sell_orders(orders),
our_buy_balance=our_buy_balance,
our_sell_balance=our_sell_balance,
target_price=target_price)[0])
def synchronize_orders(self):
# If keeper balance is below `--min-eth-balance`, cancel all orders but do not terminate
# the keeper, keep processing blocks as the moment the keeper gets a top-up it should
# resume activity straight away, without the need to restart it.
#
# The exception is when we can withdraw some ETH from EtherDelta. Then we do it and carry on.
if eth_balance(self.web3, self.our_address) < self.min_eth_balance:
if self.etherdelta.balance_of(self.our_address) > self.eth_reserve:
self.logger.warning(f"Keeper ETH balance below minimum, withdrawing {self.eth_reserve}.")
self.etherdelta.withdraw(self.eth_reserve).transact()
else:
self.logger.warning(f"Keeper ETH balance below minimum, cannot withdraw. Cancelling all orders.")
self.cancel_all_orders()
return
bands = Bands(self.bands_config, self.spread_feed, self.history)
block_number = self.web3.eth.blockNumber
target_price = self.price_feed.get_price()
# Remove expired orders from the local order list
self.remove_expired_orders(block_number)
# Cancel orders
cancellable_orders = bands.cancellable_orders(self.our_buy_orders(), self.our_sell_orders(), target_price)
if len(cancellable_orders) > 0:
self.cancel_orders(cancellable_orders, block_number)
return
# In case of EtherDelta, balances returned by `our_total_balance` still contain amounts "locked"
# by currently open orders, so we need to explicitly subtract these amounts.
our_buy_balance = self.our_total_balance(self.token_buy()) - Bands.total_amount(self.our_buy_orders())
our_sell_balance = self.our_total_balance(self.token_sell()) - Bands.total_amount(self.our_sell_orders())
# Evaluate if we need to create new orders, and how much do we need to deposit
new_orders, missing_buy_amount, missing_sell_amount = bands.new_orders(our_buy_orders=self.our_buy_orders(),
our_sell_orders=self.our_sell_orders(),
our_buy_balance=our_buy_balance,
our_sell_balance=our_sell_balance,
target_price=target_price)
# If deposited amount too low for placing buy orders, try to deposit.
# If deposited amount too low for placing sell orders, try to deposit.
made_deposit = False
if missing_buy_amount > Wad(0):
if self.deposit_for_buy_order():
made_deposit = True
if missing_sell_amount > Wad(0):
if self.deposit_for_sell_order():
made_deposit = True
# If we managed to deposit something, do not do anything so we can reevaluate new orders to be created.
# Otherwise, create new orders.
if not made_deposit:
self.place_orders(new_orders)
def synchronize_orders(self):
if eth_balance(self.web3, self.our_address) < self.min_eth_balance:
self.logger.warning(
"Keeper ETH balance below minimum. Cancelling all orders.")
self.order_book_manager.cancel_all_orders()
return
bands = Bands(self.bands_config, self.spread_feed, self.history)
order_book = self.order_book_manager.get_order_book()
target_price = self.price_feed.get_price()
# Cancel orders
cancellable_orders = bands.cancellable_orders(
our_buy_orders=self.our_buy_orders(order_book.orders),
our_sell_orders=self.our_sell_orders(order_book.orders),
target_price=target_price)
if len(cancellable_orders) > 0:
self.order_book_manager.cancel_orders(cancellable_orders)
return
# Do not place new orders if order book state is not confirmed
if order_book.orders_being_placed or order_book.orders_being_cancelled:
self.logger.debug(
"Order book is in progress, not placing new orders")
return
# In case of Ddex, balances returned by `our_total_balance` still contain amounts "locked"
# by currently open orders, so we need to explicitly subtract these amounts.
our_buy_balance = self.our_total_balance(
self.token_buy) - Bands.total_amount(
self.our_buy_orders(order_book.orders))
our_sell_balance = self.our_total_balance(
self.token_sell) - Bands.total_amount(
self.our_sell_orders(order_book.orders))
# Place new orders
self.place_orders(
bands.new_orders(
our_buy_orders=self.our_buy_orders(order_book.orders),
our_sell_orders=self.our_sell_orders(order_book.orders),
our_buy_balance=our_buy_balance,
our_sell_balance=our_sell_balance,
target_price=target_price)[0])
def synchronize_orders(self):
if eth_balance(self.web3, self.our_address) < self.min_eth_balance:
self.logger.warning(
"Keeper ETH balance below minimum. Cancelling all orders.")
self.cancel_orders(self.our_orders())
return
bands = Bands(self.bands_config, self.spread_feed, self.history)
our_orders = self.our_orders()
target_price = self.price_feed.get_price()
# Cancel orders
cancellable_orders = bands.cancellable_orders(
our_buy_orders=self.our_buy_orders(our_orders),
our_sell_orders=self.our_sell_orders(our_orders),
target_price=target_price)
if len(cancellable_orders) > 0:
self.cancel_orders(cancellable_orders)
return
# In case of Paradex, balances returned by `our_total_balance` still contain amounts "locked"
# by currently open orders, so we need to explicitly subtract these amounts.
our_buy_balance = self.our_total_balance(
self.token_buy) - Bands.total_amount(
self.our_buy_orders(our_orders))
our_sell_balance = self.our_total_balance(
self.token_sell) - Bands.total_amount(
self.our_sell_orders(our_orders))
# Place new orders
self.place_orders(
bands.new_orders(our_buy_orders=self.our_buy_orders(our_orders),
our_sell_orders=self.our_sell_orders(our_orders),
our_buy_balance=our_buy_balance,
our_sell_balance=our_sell_balance,
target_price=target_price)[0])
def synchronize_orders(self):
# If keeper balance is below `--min-eth-balance`, cancel all orders but do not terminate
# the keeper, keep processing blocks as the moment the keeper gets a top-up it should
# resume activity straight away, without the need to restart it.
#
# The exception is when we can withdraw some ETH from EtherDelta. Then we do it and carry on.
if eth_balance(self.web3, self.our_address) < self.min_eth_balance:
if self.etherdelta.balance_of(self.our_address) > self.eth_reserve:
self.logger.warning(
f"Keeper ETH balance below minimum, withdrawing {self.eth_reserve}."
)
self.etherdelta.withdraw(self.eth_reserve).transact()
else:
self.logger.warning(
f"Keeper ETH balance below minimum, cannot withdraw. Cancelling all orders."
)
self.cancel_all_orders()
return
bands = Bands.read(self.bands_config, self.spread_feed,
self.control_feed, self.history)
block_number = self.web3.eth.blockNumber
target_price = self.price_feed.get_price()
# Remove expired orders from the local order list
self.remove_expired_orders(block_number)
# Cancel orders
cancellable_orders = bands.cancellable_orders(self.our_buy_orders(),
self.our_sell_orders(),
target_price)
if len(cancellable_orders) > 0:
self.cancel_orders(cancellable_orders, block_number)
return
# In case of EtherDelta, balances returned by `our_total_balance` still contain amounts "locked"
# by currently open orders, so we need to explicitly subtract these amounts.
our_buy_balance = self.our_total_balance(
self.token_buy()) - Bands.total_amount(self.our_buy_orders())
our_sell_balance = self.our_total_balance(
self.token_sell()) - Bands.total_amount(self.our_sell_orders())
# Evaluate if we need to create new orders, and how much do we need to deposit
new_orders, missing_buy_amount, missing_sell_amount = bands.new_orders(
our_buy_orders=self.our_buy_orders(),
our_sell_orders=self.our_sell_orders(),
our_buy_balance=our_buy_balance,
our_sell_balance=our_sell_balance,
target_price=target_price)
# If deposited amount too low for placing buy orders, try to deposit.
# If deposited amount too low for placing sell orders, try to deposit.
made_deposit = False
if missing_buy_amount > Wad(0):
if self.deposit_for_buy_order():
made_deposit = True
if missing_sell_amount > Wad(0):
if self.deposit_for_sell_order():
made_deposit = True
# If we managed to deposit something, do not do anything so we can reevaluate new orders to be created.
# Otherwise, create new orders.
if not made_deposit:
self.place_orders(new_orders)
