def __repr__(self):
try:
h = self.hash
except Exception:
h = b''
return '<%s(%s) ask: %s[%s] bid %s[%s] h:%s>' % (
self.__class__.__name__,
pex(int_to_big_endian(self.offer_id)),
pex(self.ask_token),
self.ask_amount,
pex(self.bid_token),
self.bid_amount,
pex(h),
)
def __repr__(self):
return "{}<initiator={}, amount={}, identifier={}>".format(
self.__class__.__name__,
pex(self.initiator),
self.amount,
self.identifier,
)
def __repr__(self):
return "{}<initiator={}, amount={}, identifier={}, timestamp={}>".format(
self.__class__.__name__,
pex(self.initiator),
self.amount,
self.identifier,
timestamp.to_str_repr(self.timestamp)
)
def transfer(self, target_address, amount, identifier):
# type: (str, (int, long), (int, long)) -> bool
if not self.commitment_balance >= amount:
# insufficient funds
return False
successful = self.trader.transfer(self.address, target_address, amount, identifier)
if successful is True:
self.commitment_balance -= amount
log.debug('{} transferred {} to {} for pex(id): {}'.format(self, amount, pex(target_address), pex(int_to_big_endian(identifier))))
return successful
def process(self, data):
msg, recipient = data
self._sign_func(msg)
# FIXME make async
# recipient == None is indicating a broadcast
if recipient is None:
success = self.message_broker.broadcast(msg)
if success is True:
log_messaging.debug('Broadcast successful: {}'.format(msg))
else:
success = self.message_broker.send(topic=recipient, message=msg)
if success is True:
log_messaging.debug(
'Sending successful: {} // recipient={}'.format(
msg, pex(recipient)))
def __repr__(self):
return "TokenPair<base={}, quote={}".format(pex(self.base_token),
pex(self.quote_token))
def __repr__(self):
#try:
h = self.hash
#except Exception:
# h = b''
return '<%s(%s)>' % (self.__class__.__name__, pex(h))
def transfer(self, self_address, target_address, amount, identifier):
transfer_received_event = EventPaymentReceivedSuccess(initiator=self_address, amount=amount, identifier=identifier)
# for this mock-implementation:
# a transfer can only go through when a listener is found
try:
listeners = self.listeners[target_address]
except KeyError:
log_tglobal.debug('No listener found for incoming transfer: target_address={}>'.format(pex(target_address)))
return False
# NOTE: even if we don't raise a key error here, the 'transfer' will only properly go through,
# when some TransferReceivedListener and a TraderClients BalanceUpdateTask is listening for the events
# for that address
#
# In a non-Mocked scenario (with raiden) we expect to get a success notifcation, so we know if the transfer
# went through or not
for listener in listeners:
address, event_queue_async, transform = listener
event = transfer_received_event
transformed_event = event
if transform is not None:
transformed_event = transform(transformed_event)
if transformed_event is not None:
event_queue_async.put(transformed_event)
return True
def __repr__(self):
return 'TraderClient<{}>'.format(pex(self.address), self.commitment_balance)
def process(self, data):
swap_completed = data
log.debug('Offer {} has been successfully traded'.format(
pex(int_to_big_endian(swap_completed.offer_id))))
self.trades.report_completed(swap_completed.offer_id,
swap_completed.timestamp)
def __repr__(self):
return "Offer<pex(id)={} amount={} price={} type={} timeout={}>".format(
pex(int_to_big_endian(self.offer_id)), self.base_amount,
self.price, self.type, to_str_repr(self.timeout_date))
