def handle_market_order(self, amount, price, type_to_place, tx_id):
log.info(
'handle market order price: {}, amount: {}, type_to_place: {}'.
format(price, amount, type_to_place))
last_id_before_market = get_last_order(self.mutex_UUID)
if type_to_place == BUY:
self.exchange.market_buy(amount, price)
elif type_to_place == SELL:
self.exchange.market_sell(amount, price)
current_history = self.exchange.get_my_trade_history()
if self.exchange.name != 'tux':
self.exchange.process_new_transactions(current_history)
market_history = get_new_history(current_history,
last_id_before_market)
market_data = get_market_results(market_history)
# The sell gave us some BTC. The buy is executed with that BTC.
# The market buy will get us X xmr in return. All of that xmr
# should be placed at the original order's matching price.
#
# We need to do something here about the partials if it doesnt fully fill
amount_executed = Decimal(market_data['amount_executed'])
price_numerator = Decimal(market_data['price_numerator'])
last_txid = market_data['last_txid']
log.info('market data: {}'.format(market_data))
update_merkato(self.mutex_UUID, LAST_ORDER, last_txid)
market_order_filled = amount <= amount_executed
if market_order_filled:
if type_to_place == BUY:
price = price * Decimal(1 + self.spread)
self.exchange.sell(amount_executed,
price) # Should never market order
elif type_to_place == SELL:
price = price * Decimal(1 - self.spread)
self.exchange.buy(amount_executed, price)
else:
log.info(
'handle_market_order: partials affected, amount: {} amount_executed: {}'
.format(amount, amount_executed))
if type_to_place == BUY:
self.quote_partials_balance += amount_executed
update_merkato(self.mutex_UUID, 'quote_partials_balance',
float(self.quote_partials_balance))
log.info('market buy partials after: {}'.format(
self.quote_partials_balance))
else:
self.base_partials_balance += amount_executed * price_numerator
update_merkato(self.mutex_UUID, 'base_partials_balance',
float(self.base_partials_balance))
log.info('market sell partials after {}'.format(
self.base_partials_balance))
def rebalance_orders(self, new_txes):
# This function places a matching order for every new transaction since last run
#
# profit_margin is a number from 0 to 1 representing the percent of the spread to return
# to the user's balance before placing the matching order.
#
# TODO: Modify so that the parent function only passes in the new transactions, don't
# do the index check internally.
# new_history is an array of transactions
# new_txes is the number of new transactions contained in new_history
factor = self.spread*self.profit_margin/2
ordered_transactions = new_txes
log.info('ordered transactions rebalanced: {}'.format(ordered_transactions))
for tx in ordered_transactions:
log.info('length of ordered_transactions length length: {}'.format(len(ordered_transactions)))
if tx['type'] == SELL:
log.info("Found sell {} corresponding buy {}".format(tx, sell_price))
amount = float(tx['amount']) * float(tx[PRICE])*(1-factor)
price = float(tx[PRICE])
buy_price = price * ( 1 - self.spread)
log.info("found sell {}; corresponding buy {}".format(tx, buy_price))
market = self.exchange.buy(amount, buy_price)
if market == MARKET:
log.info('market sell', market)
last_order_time = str(int(time.time()))
self.exchange.market_buy(amount, buy_price)
market_history = self.exchange.get_my_trade_history(start=last_order_time)
market_data = get_market_results(market_history)
# We have a sell executed. We want to place a matching buy order.
# If the whole order is executed, no edge case.
# If the order has a remainder, the remainder will be on the books at
# the appropriate price. So no problem.
# If the remainder is too small to have a matching order, it could
# disappear, but this is such a minor edge case we can ignore it.
#
# The sell gave us some BTC. The buy is executed with that BTC.
# The market buy will get us X xmr in return. All of that xmr
# should be placed at the original order's matching price.
amount_executed = float(market_data['amount_executed'])
last_orderid = market_data['last_orderid']
log.info('market data: {}'.format(market_data))
self.exchange.sell(amount_executed, price) # Should never market order
# A market buy occurred, so we need to update the db with the latest tx
update_merkato(self.mutex_UUID, LAST_ORDER, last_orderid)
if tx['type'] == BUY:
amount = float(tx['amount'])*float((1-factor))
price = tx[PRICE]
sell_price = float(price) * ( 1 + self.spread)
log.info("Found buy {} corresponding sell {}".format(tx, sell_price))
market = self.exchange.sell(amount, sell_price)
if market == MARKET:
log.info('market buy {}'.format(market))
last_order_time = str(int(time.time()))
self.exchange.market_sell(amount, sell_price)
market_history = self.exchange.get_my_trade_history(start=last_order_time)
market_data = get_market_results(market_history)
# We have a buy executed. We want to place a matching sell order.
# If the whole order is executed, no edge case.
# If the order has a remainder, the remainder will be on the books at
# the appropriate price. So no problem.
# If the remainder is too small to have a matching order, it could
# disappear, but this is such a minor edge case we can ignore it.
#
# The buy gave us some alt. The sell is executed with that alt.
# The market sell will get us X btc in return. All of that btc
# should be placed at the original order's matching price.
amount_executed = float(market_data['total_gotten'])
last_orderid = market_data['last_orderid']
log.info('market data {}'.format(market_data))
self.exchange.buy(amount_executed, float(price)) # Should never market order
# A market buy occurred, so we need to update the db with the latest tx
update_merkato(self.mutex_UUID, LAST_ORDER, last_orderid)
if market != MARKET:
log.info('market != MARKET market != MARKET')
update_merkato(self.mutex_UUID, LAST_ORDER, tx['orderId'])
first_order = get_first_order(self.mutex_UUID)
no_first_order = first_order == ''
if no_first_order:
update_merkato(self.mutex_UUID, FIRST_ORDER, tx['orderId'])
self.log_new_transactions(ordered_transactions)
return ordered_transactions