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))