def handle_taker_call(data_manager: DataManager, state_change: TakerCallStateChange):
offer_id = state_change.offer_id
offer = data_manager.offer_manager.get_offer(offer_id)
match = MatchFactory.maker_match(offer, state_change.initiator, state_change.commitment_proof)
data_manager.matches[offer_id] = match
match.matched()
def __init__(self, address, token_pair, message_broker, trader_client):
super(RaidexNode, self).__init__(StateChange)
self.token_pair = token_pair
self.address = address
self.message_broker = message_broker
self.trader_client = trader_client
self.offer_book = OfferBook()
# don't make this accessible in the constructor args for now, set attribute instead if needed
self.default_offer_lifetime = 30
self._trades_view = TradesView()
self.order_tasks_by_id = {}
self.user_order_tasks_by_id = {}
self._nof_successful_orders = 0
self._nof_unsuccessful_orders = 0
self._max_open_orders = 0
self._get_trades = self._trades_view.trades
self.data_manager = DataManager(self.offer_book, token_pair)
self.raiden_info = RaidenInfo()
def handle_cancel_limit_order(data_manager: DataManager, state_change: CancelLimitOrderStateChange):
order_id = state_change.data['order_id']
data_manager.cancel_order(order_id)
def handle_new_limit_order(data_manager: DataManager, state_change: NewLimitOrderStateChange):
new_order = LimitOrder.from_dict(state_change.data)
data_manager.process_order(new_order)
class RaidexNode(Processor):
def __init__(self, address, token_pair, message_broker, trader_client):
super(RaidexNode, self).__init__(StateChange)
self.token_pair = token_pair
self.address = address
self.message_broker = message_broker
self.trader_client = trader_client
self.offer_book = OfferBook()
# don't make this accessible in the constructor args for now, set attribute instead if needed
self.default_offer_lifetime = 30
self._trades_view = TradesView()
self.order_tasks_by_id = {}
self.user_order_tasks_by_id = {}
self._nof_successful_orders = 0
self._nof_unsuccessful_orders = 0
self._max_open_orders = 0
self._get_trades = self._trades_view.trades
self.data_manager = DataManager(self.offer_book, token_pair)
self.raiden_info = RaidenInfo()
def start(self):
log.info('Starting raidex node')
OfferBookTask(self.offer_book, self.token_pair,
self.message_broker).start()
self.raiden_info.start()
def _process_finished_limit_order(self, order_task):
value = order_task.get(block=False)
if value is True:
self._nof_successful_orders += 1
elif value is False:
self._nof_unsuccessful_orders += 1
return self.user_order_tasks_by_id.pop(order_task.order_id, None)
@property
def successful_orders(self):
return self._nof_successful_orders
@property
def unsuccessful_orders(self):
return self._nof_unsuccessful_orders
@property
def open_orders(self):
return self.data_manager.get_open_orders()
@property
def finished_orders(self):
return self._nof_successful_orders + self._nof_unsuccessful_orders
@property
def initiated_orders(self):
return self.data_manager.orders.values()
def limit_orders(self):
# we only keep a reference of user-initiated LimitOrders at the moment
raise NotImplementedError()
def cancel_limit_order(self, order_id):
log.info('Cancel limit order')
self.user_order_tasks_by_id[order_id].cancel()
def print_offers(self):
print(self.offer_book)
def buys(self):
return self.offer_book.buys.values()
def sells(self):
return self.offer_book.sells.values()
def grouped_buys(self):
return group_offers(self.buys())
def grouped_sells(self):
return group_offers(self.sells())
def trades(self, from_timestamp=None):
return self._get_trades(from_timestamp=from_timestamp)
def grouped_trades(self, from_timestamp=None):
return group_trades_from(self._get_trades, from_timestamp)
def recent_grouped_trades(self, chunk_size):
return get_n_recent_trades(self.trades(), chunk_size)
def price_chart_bins(self, nof_buckets, interval):
if nof_buckets < 1 or interval < 0.:
raise ValueError()
return make_price_bins(self._get_trades, nof_buckets, interval)
def market_price(self, trade_count=20):
"""Calculate a market price based on the most recent trades.
:param trade_count: number of redent trades to consider
:returns: a market price, or `None` if no trades have happened yet
"""
trades_list = self._get_trades(trade_count)
trades = list(reversed(trades_list[-trade_count:]))
if len(trades) == 0:
return None
else:
assert sorted(
trades,
key=lambda t: -t.timestamp) == trades # newest should be first
total_volume = sum([t.offer.amount for t in trades])
return sum([t.offer.price * t.offer.amount
for t in trades]) / total_volume
def get_channels(self):
return self.raiden_info.get_channels()
@property
def commitment_service_address(self):
return CS_ADDRESS