def __init__(self, chain, private_key_bin, transport, discovery, config): # pylint: disable=too-many-arguments if not isinstance(private_key_bin, bytes) or len(private_key_bin) != 32: raise ValueError('invalid private_key') private_key = PrivateKey( private_key_bin, ctx=GLOBAL_CTX, raw=True, ) pubkey = private_key.pubkey.serialize(compressed=False) self.registries = list() self.managers_by_asset_address = dict() self.managers_by_address = dict() self.chain = chain self.config = config self.privkey = private_key_bin self.pubkey = pubkey self.private_key = private_key self.address = privatekey_to_address(private_key_bin) self.protocol = RaidenProtocol(transport, discovery, self) transport.protocol = self.protocol message_handler = RaidenMessageHandler(self) event_handler = RaidenEventHandler(self) alarm = AlarmTask(chain) # ignore the blocknumber alarm.register_callback( lambda _: event_handler.poll_all_event_listeners()) alarm.start() self._blocknumber = alarm.last_block_number alarm.register_callback(self.set_block_number) if config['max_unresponsive_time'] > 0: self.healthcheck = HealthcheckTask(self, config['send_ping_time'], config['max_unresponsive_time']) self.healthcheck.start() else: self.healthcheck = None self.api = RaidenAPI(self) self.alarm = alarm self.event_handler = event_handler self.message_handler = message_handler self.start_event_listener = event_handler.start_event_listener self.on_message = message_handler.on_message self.on_event = event_handler.on_event
def __init__(self, chain, private_key_bin, transport, discovery, config): if not isinstance(private_key_bin, bytes) or len(private_key_bin) != 32: raise ValueError('invalid private_key') private_key = PrivateKey(private_key_bin) pubkey = private_key.public_key.format(compressed=False) self.channelgraphs = dict() self.manager_token = dict() self.swapkeys_tokenswaps = dict() self.swapkeys_greenlettasks = dict() self.identifier_statemanager = defaultdict(list) self.identifier_result = defaultdict(list) # This is a map from a hashlock to a list of channels, the same # hashlock can be used in more than one token (for tokenswaps), a # channel should be removed from this list only when the lock is # released/withdrawn but not when the secret is registered. self.tokens_hashlocks_channels = defaultdict(lambda: defaultdict(list)) self.chain = chain self.config = config self.privkey = private_key_bin self.pubkey = pubkey self.private_key = private_key self.address = privatekey_to_address(private_key_bin) self.protocol = RaidenProtocol(transport, discovery, self) transport.protocol = self.protocol message_handler = RaidenMessageHandler(self) state_machine_event_handler = StateMachineEventHandler(self) pyethapp_blockchain_events = PyethappBlockchainEvents() greenlet_task_dispatcher = GreenletTasksDispatcher() alarm = AlarmTask(chain) # ignore the blocknumber alarm.register_callback(self.poll_blockchain_events) alarm.start() self._blocknumber = alarm.last_block_number alarm.register_callback(self.set_block_number) if config['max_unresponsive_time'] > 0: self.healthcheck = HealthcheckTask( self, config['send_ping_time'], config['max_unresponsive_time'] ) self.healthcheck.start() else: self.healthcheck = None self.api = RaidenAPI(self) self.alarm = alarm self.message_handler = message_handler self.state_machine_event_handler = state_machine_event_handler self.pyethapp_blockchain_events = pyethapp_blockchain_events self.greenlet_task_dispatcher = greenlet_task_dispatcher self.on_message = message_handler.on_message self.tokens_connectionmanagers = dict() # token_address: ConnectionManager
def __init__(self, chain, private_key_bin, transport, discovery, config): # pylint: disable=too-many-arguments if not isinstance(private_key_bin, bytes) or len(private_key_bin) != 32: raise ValueError('invalid private_key') private_key = PrivateKey( private_key_bin, ctx=GLOBAL_CTX, raw=True, ) pubkey = private_key.pubkey.serialize(compressed=False) self.registries = list() self.managers_by_token_address = dict() self.managers_by_address = dict() self.chain = chain self.config = config self.privkey = private_key_bin self.pubkey = pubkey self.private_key = private_key self.address = privatekey_to_address(private_key_bin) self.protocol = RaidenProtocol(transport, discovery, self) transport.protocol = self.protocol message_handler = RaidenMessageHandler(self) event_handler = RaidenEventHandler(self) alarm = AlarmTask(chain) # ignore the blocknumber alarm.register_callback( lambda _: event_handler.poll_all_event_listeners()) alarm.start() self._blocknumber = alarm.last_block_number alarm.register_callback(self.set_block_number) if config['max_unresponsive_time'] > 0: self.healthcheck = HealthcheckTask(self, config['send_ping_time'], config['max_unresponsive_time']) self.healthcheck.start() else: self.healthcheck = None self.api = RaidenAPI(self) self.alarm = alarm self.event_handler = event_handler self.message_handler = message_handler self.start_event_listener = event_handler.start_event_listener self.on_message = message_handler.on_message self.on_event = event_handler.on_event self.api_event_manager = APIEventManager(self) # Adding events to Queue should be stopped if connection closed by client, # and a max-size of the Queue should be introduced! # At the moment, as soon as the callbacks are registered, the Queue will fill indefinately, # if no client polls the Events from the Queue self.api_event_manager.register_callbacks()