def _search_for_quantity_in_price_level_total(self, tick_entry, quantity_to_trade, order):
if tick_entry.quantity <= Quantity(0):
return quantity_to_trade, []
trading_quantity = quantity_to_trade
quantity_to_trade = Quantity(0)
self._logger.debug("Match with the id (%s) was found for order (%s). Price: %i, Quantity: %i)",
str(tick_entry.order_id), str(order.order_id), int(tick_entry.price), int(trading_quantity))
reserved = order.reserve_quantity_for_tick(tick_entry.tick.order_id, trading_quantity)
if not reserved: # Error happened
self._logger.warn("Something went wrong")
return self._search_for_quantity_in_price_level(tick_entry.next_tick(), quantity_to_trade, order)
proposed_trades = [Trade.propose(
self.order_book.message_repository.next_identity(),
order.order_id,
tick_entry.order_id,
tick_entry.price,
trading_quantity,
Timestamp.now()
)]
return quantity_to_trade, proposed_trades
def _search_for_quantity_in_price_level_partial(self, tick_entry, quantity_to_trade, order):
quantity_to_trade -= tick_entry.quantity
self._logger.debug("Match with the id (%s) was found for order (%s) ", str(tick_entry.order_id),
str(order.order_id))
reserved = order.reserve_quantity_for_tick(tick_entry.tick.order_id, tick_entry.quantity)
if not reserved: # Error happened
self._logger.warn("Something went wrong")
return self._search_for_quantity_in_price_level(tick_entry.next_tick(), quantity_to_trade, order)
proposed_trades = [Trade.propose(
self.order_book.message_repository.next_identity(),
order.order_id,
tick_entry.order_id,
tick_entry.price,
tick_entry.quantity,
Timestamp.now()
)]
# Search the next tick
quantity_to_trade, trades = self._search_for_quantity_in_price_level(tick_entry.next_tick(),
quantity_to_trade,
order)
proposed_trades = proposed_trades + trades
return quantity_to_trade, proposed_trades
def create_bitcoin_payment(self, message_id, transaction, multi_chain_payment):
bitcoin_payment = BitcoinPayment(message_id, transaction.transaction_id, multi_chain_payment.bitcoin_address,
multi_chain_payment.transferee_price, Timestamp.now())
transaction.add_payment(bitcoin_payment)
self.transaction_repository.update(transaction)
return bitcoin_payment
def create_multi_chain_payment(self, message_id, transaction):
payment = transaction.next_payment()
multi_chain_payment = MultiChainPayment(message_id, transaction.transaction_id, BitcoinAddress(''), payment[0],
payment[1],
Timestamp.now())
transaction.add_payment(multi_chain_payment)
self.transaction_repository.update(transaction)
return multi_chain_payment
def add_trade(self, other_order_id, quantity):
self._logger.debug("Adding trade for order %s with quantity %s (other id: %s)",
str(self.order_id), quantity, str(other_order_id))
self._traded_quantity += quantity
try:
self.release_quantity_for_tick(other_order_id)
except TickWasNotReserved:
pass
assert self.available_quantity >= Quantity(0)
if self.is_complete():
self._completed_timestamp = Timestamp.now()
def create_bid_order(self, price, quantity, timeout):
"""
Create a bid order (buy order)
:param price: The price for the order
:param quantity: The quantity of the order
:param timeout: The timeout of the order, when does the order need to be timed out
:type price: Price
:type quantity: Quantity
:type timeout: Timeout
:return: The order that is created
:rtype: Order
"""
assert isinstance(price, Price), type(price)
assert isinstance(quantity, Quantity), type(quantity)
assert isinstance(timeout, Timeout), type(timeout)
order = Order(self.order_repository.next_identity(), price, quantity,
timeout, Timestamp.now(), False)
self.order_repository.add(order)
self._logger.info("Bid order created with id: " + str(order.order_id))
return order
def is_valid(self):
"""
:return: True if valid, False otherwise
:rtype: bool
"""
return not self._timeout.is_timed_out(Timestamp.now())
def cancel(self):
self._timeout = Timestamp.now()
def test_now():
"""Test that Timestamp.now() returns some reasonable number."""
assert Timestamp.now() > 1628000000
def create_from_start_transaction(self, start_transaction, timeout):
"""
:type start_transaction: StartTransaction
:type timeout: Timeout
:rtype: Transaction
"""
assert isinstance(start_transaction, StartTransaction), type(start_transaction)
assert isinstance(timeout, Timeout), type(timeout)
transaction = Transaction(start_transaction.transaction_id, start_transaction.transaction_id.trader_id,
start_transaction.price, start_transaction.quantity, timeout, Timestamp.now())
self.transaction_repository.add(transaction)
self._logger.info("Transaction created with id: %s, quantity: %s, price: %s",
str(transaction.transaction_id), str(transaction.total_quantity), str(transaction.price))
return transaction