def get_token_network_events(self, token_address, from_block, to_block='latest'): if not isaddress(token_address): raise InvalidAddress( 'Expected binary address format for token in get_token_network_events' ) channel_manager_address = self.raiden.default_registry.manager_address_by_token( token_address) returned_events = get_all_channel_manager_events( self.raiden.chain, channel_manager_address, events=ALL_EVENTS, from_block=from_block, to_block=to_block, ) raiden_events = self.raiden.wal.storage.get_events_by_block( from_block=from_block, to_block=to_block, ) # Here choose which raiden internal events we want to expose to the end user for block_number, event in raiden_events: if isinstance(event, EVENTS_EXTERNALLY_VISIBLE): new_event = { 'block_number': block_number, 'event': type(event).__name__, } new_event.update(event.__dict__) returned_events.append(new_event) return returned_events
def get_token_network_events(self, token_address, from_block, to_block): if not isaddress(token_address): raise InvalidAddress( 'Expected binary address format for token in get_token_network_events' ) graph = self.raiden.token_to_channelgraph[token_address] return get_all_channel_manager_events( self.raiden.chain, graph.channelmanager_address, events=ALL_EVENTS, from_block=from_block, to_block=to_block, )
def get_token_network_events(self, token_address, from_block, to_block): if not isaddress(token_address): raise InvalidAddress( 'Expected binary address format for token in get_token_network_events' ) try: graph = self.raiden.token_to_channelgraph[token_address] return get_all_channel_manager_events( self.raiden.chain, graph.channelmanager_address, events=ALL_EVENTS, from_block=from_block, to_block=to_block, ) except KeyError: raise UnknownTokenAddress('The token address is not registered.')
def test_query_events(raiden_chain, token_addresses, deposit, settle_timeout, events_poll_timeout): app0, app1 = raiden_chain # pylint: disable=unbalanced-tuple-unpacking registry_address = app0.raiden.default_registry.address token_address = token_addresses[0] token_network_identifier = views.get_token_network_identifier_by_token_address( views.state_from_app(app0), registry_address, token_address, ) manager0 = app0.raiden.default_registry.manager_by_token(token_address) channelcount0 = views.total_token_network_channels( views.state_from_app(app0), registry_address, token_address, ) events = get_all_registry_events( app0.raiden.chain, registry_address, events=ALL_EVENTS, from_block=0, to_block='latest', ) assert len(events) == 1 assert events[0]['event'] == EVENT_TOKEN_ADDED assert event_dicts_are_equal( events[0]['args'], { 'registry_address': to_normalized_address(registry_address), 'channel_manager_address': to_normalized_address(manager0.address), 'token_address': to_normalized_address(token_address), 'block_number': 'ignore', }) events = get_all_registry_events( app0.raiden.chain, app0.raiden.default_registry.address, events=ALL_EVENTS, from_block=999999998, to_block=999999999, ) assert not events channel_address = RaidenAPI(app0.raiden).channel_open( registry_address, token_address, app1.raiden.address, ) gevent.sleep(events_poll_timeout * 2) events = get_all_channel_manager_events( app0.raiden.chain, manager0.address, events=ALL_EVENTS, from_block=0, to_block='latest', ) assert len(events) == 1 assert events[0]['event'] == EVENT_CHANNEL_NEW assert event_dicts_are_equal( events[0]['args'], { 'registry_address': to_normalized_address(registry_address), 'settle_timeout': settle_timeout, 'netting_channel': to_normalized_address(channel_address), 'participant1': to_normalized_address(app0.raiden.address), 'participant2': to_normalized_address(app1.raiden.address), 'block_number': 'ignore', }) events = get_all_channel_manager_events( app0.raiden.chain, manager0.address, events=ALL_EVENTS, from_block=999999998, to_block=999999999, ) assert not events # channel is created but not opened and without funds channelcount1 = views.total_token_network_channels( views.state_from_app(app0), registry_address, token_address, ) assert channelcount0 + 1 == channelcount1 assert_synched_channel_state( token_network_identifier, app0, 0, [], app1, 0, [], ) RaidenAPI(app0.raiden).set_total_channel_deposit( registry_address, token_address, app1.raiden.address, deposit, ) gevent.sleep(events_poll_timeout * 2) all_netting_channel_events = get_all_netting_channel_events( app0.raiden.chain, channel_address, from_block=0, to_block='latest', ) events = get_all_netting_channel_events( app0.raiden.chain, channel_address, events=[CONTRACT_MANAGER.get_event_id(EVENT_CHANNEL_NEW_BALANCE)], ) assert len(all_netting_channel_events) == 1 assert len(events) == 1 assert events[0]['event'] == EVENT_CHANNEL_NEW_BALANCE new_balance_event = { 'registry_address': to_normalized_address(registry_address), 'token_address': to_normalized_address(token_address), 'participant': to_normalized_address(app0.raiden.address), 'balance': deposit, 'block_number': 'ignore', } assert event_dicts_are_equal(all_netting_channel_events[-1]['args'], new_balance_event) assert event_dicts_are_equal(events[0]['args'], new_balance_event) RaidenAPI(app0.raiden).channel_close( registry_address, token_address, app1.raiden.address, ) gevent.sleep(events_poll_timeout * 2) all_netting_channel_events = get_all_netting_channel_events( app0.raiden.chain, netting_channel_address=channel_address, from_block=0, to_block='latest', ) events = get_all_netting_channel_events( app0.raiden.chain, channel_address, events=[CONTRACT_MANAGER.get_event_id(EVENT_CHANNEL_CLOSED)], ) assert len(all_netting_channel_events) == 2 assert len(events) == 1 assert events[0]['event'] == EVENT_CHANNEL_CLOSED closed_event = { 'registry_address': to_normalized_address(registry_address), 'closing_address': to_normalized_address(app0.raiden.address), 'block_number': 'ignore', } assert event_dicts_are_equal(all_netting_channel_events[-1]['args'], closed_event) assert event_dicts_are_equal(events[0]['args'], closed_event) settle_expiration = app0.raiden.chain.block_number() + settle_timeout + 5 wait_until_block(app0.raiden.chain, settle_expiration) all_netting_channel_events = get_all_netting_channel_events( app0.raiden.chain, netting_channel_address=channel_address, from_block=0, to_block='latest', ) events = get_all_netting_channel_events( app0.raiden.chain, channel_address, events=[CONTRACT_MANAGER.get_event_id(EVENT_CHANNEL_SETTLED)], ) assert len(all_netting_channel_events) == 3 assert len(events) == 1 assert events[0]['event'] == EVENT_CHANNEL_SETTLED settled_event = { 'registry_address': to_normalized_address(registry_address), 'block_number': 'ignore', } assert event_dicts_are_equal(all_netting_channel_events[-1]['args'], settled_event) assert event_dicts_are_equal(events[0]['args'], settled_event)
def test_query_events(raiden_chain, deposit, settle_timeout, events_poll_timeout): app0, app1 = raiden_chain # pylint: disable=unbalanced-tuple-unpacking token_address = app0.raiden.default_registry.token_addresses()[0] assert len(app0.raiden.token_to_channelgraph[token_address]. address_to_channel) == 0 assert len(app1.raiden.token_to_channelgraph[token_address]. address_to_channel) == 0 token0 = app0.raiden.chain.token(token_address) manager0 = app0.raiden.default_registry.manager_by_token(token_address) events = get_all_registry_events( app0.raiden.chain, app0.raiden.default_registry.address, events=ALL_EVENTS, from_block=0, to_block='latest', ) assert len(events) == 1 assert event_dicts_are_equal( events[0], { '_event_type': 'TokenAdded', 'channel_manager_address': address_encoder(manager0.address), 'token_address': address_encoder(token_address), 'block_number': 'ignore', }) events = get_all_registry_events( app0.raiden.chain, app0.raiden.default_registry.address, events=ALL_EVENTS, from_block=999999998, to_block=999999999, ) assert not events netcontract_address = manager0.new_netting_channel( app0.raiden.address, app1.raiden.address, settle_timeout, ) events = get_all_channel_manager_events( app0.raiden.chain, manager0.address, events=ALL_EVENTS, from_block=0, to_block='latest', ) assert len(events) == 1 assert event_dicts_are_equal( events[0], { '_event_type': 'ChannelNew', 'settle_timeout': settle_timeout, 'netting_channel': address_encoder(netcontract_address), 'participant1': address_encoder(app0.raiden.address), 'participant2': address_encoder(app1.raiden.address), 'block_number': 'ignore', }) events = get_all_channel_manager_events( app0.raiden.chain, manager0.address, events=ALL_EVENTS, from_block=999999998, to_block=999999999, ) assert not events netting_channel0 = app0.raiden.chain.netting_channel(netcontract_address) gevent.sleep(events_poll_timeout * 2) # channel is created but not opened and without funds assert len(app0.raiden.token_to_channelgraph[token_address]. address_to_channel) == 1 assert len(app1.raiden.token_to_channelgraph[token_address]. address_to_channel) == 1 channel0 = app0.raiden.token_to_channelgraph[ token_address].address_to_channel.values()[0] channel1 = app1.raiden.token_to_channelgraph[ token_address].address_to_channel.values()[0] assert_synched_channels( channel0, 0, [], channel1, 0, [], ) token0.approve(netcontract_address, deposit) netting_channel0.deposit(deposit) all_netting_channel_events = get_all_netting_channel_events( app0.raiden.chain, netting_channel_address=netcontract_address, from_block=0, to_block='latest', ) events = get_all_netting_channel_events( app0.raiden.chain, netcontract_address, events=[CONTRACT_MANAGER.get_event_id(EVENT_CHANNEL_NEW_BALANCE)], ) assert len(all_netting_channel_events) == 1 assert len(events) == 1 new_balance_event = { '_event_type': 'ChannelNewBalance', 'token_address': address_encoder(token_address), 'participant': address_encoder(app0.raiden.address), 'balance': deposit, 'block_number': 'ignore', } assert event_dicts_are_equal(all_netting_channel_events[-1], new_balance_event) assert event_dicts_are_equal(events[0], new_balance_event) channel0.external_state.close(None) all_netting_channel_events = get_all_netting_channel_events( app0.raiden.chain, netting_channel_address=netcontract_address, from_block=0, to_block='latest', ) events = get_all_netting_channel_events( app0.raiden.chain, netcontract_address, events=[CONTRACT_MANAGER.get_event_id(EVENT_CHANNEL_CLOSED)], ) assert len(all_netting_channel_events) == 2 assert len(events) == 1 closed_event = { '_event_type': 'ChannelClosed', 'closing_address': address_encoder(app0.raiden.address), 'block_number': 'ignore', } assert event_dicts_are_equal(all_netting_channel_events[-1], closed_event) assert event_dicts_are_equal(events[0], closed_event) settle_expiration = app0.raiden.chain.block_number() + settle_timeout + 1 wait_until_block(app0.raiden.chain, settle_expiration) channel1.external_state.settle() all_netting_channel_events = get_all_netting_channel_events( app0.raiden.chain, netting_channel_address=netcontract_address, from_block=0, to_block='latest', ) events = get_all_netting_channel_events( app0.raiden.chain, netcontract_address, events=[CONTRACT_MANAGER.get_event_id(EVENT_CHANNEL_SETTLED)], ) assert len(all_netting_channel_events) == 3 assert len(events) == 1 settled_event = { '_event_type': 'ChannelSettled', 'block_number': 'ignore', } assert event_dicts_are_equal(all_netting_channel_events[-1], settled_event) assert event_dicts_are_equal(events[0], settled_event)
def test_query_events(raiden_chain, deposit, settle_timeout, events_poll_timeout): app0, app1 = raiden_chain # pylint: disable=unbalanced-tuple-unpacking token_address = app0.raiden.default_registry.token_addresses()[0] assert len(app0.raiden.token_to_channelgraph[token_address].address_to_channel) == 0 assert len(app1.raiden.token_to_channelgraph[token_address].address_to_channel) == 0 token0 = app0.raiden.chain.token(token_address) manager0 = app0.raiden.default_registry.manager_by_token(token_address) events = get_all_registry_events( app0.raiden.chain, app0.raiden.default_registry.address, events=ALL_EVENTS, from_block=0, to_block='latest', ) assert len(events) == 1 assert event_dicts_are_equal(events[0], { '_event_type': b'TokenAdded', 'channel_manager_address': address_encoder(manager0.address), 'token_address': address_encoder(token_address), 'block_number': 'ignore', }) events = get_all_registry_events( app0.raiden.chain, app0.raiden.default_registry.address, events=ALL_EVENTS, from_block=999999998, to_block=999999999, ) assert not events netcontract_address = manager0.new_netting_channel( app1.raiden.address, settle_timeout, ) events = get_all_channel_manager_events( app0.raiden.chain, manager0.address, events=ALL_EVENTS, from_block=0, to_block='latest', ) assert len(events) == 1 assert event_dicts_are_equal(events[0], { '_event_type': b'ChannelNew', 'settle_timeout': settle_timeout, 'netting_channel': address_encoder(netcontract_address), 'participant1': address_encoder(app0.raiden.address), 'participant2': address_encoder(app1.raiden.address), 'block_number': 'ignore', }) events = get_all_channel_manager_events( app0.raiden.chain, manager0.address, events=ALL_EVENTS, from_block=999999998, to_block=999999999, ) assert not events netting_channel0 = app0.raiden.chain.netting_channel(netcontract_address) gevent.sleep(events_poll_timeout * 2) # channel is created but not opened and without funds assert len(app0.raiden.token_to_channelgraph[token_address].address_to_channel) == 1 assert len(app1.raiden.token_to_channelgraph[token_address].address_to_channel) == 1 channel0 = list(app0.raiden.token_to_channelgraph[token_address].address_to_channel.values())[0] # noqa: E501 channel1 = list(app1.raiden.token_to_channelgraph[token_address].address_to_channel.values())[0] # noqa: E501 assert_synched_channels( channel0, 0, [], channel1, 0, [], ) token0.approve(netcontract_address, deposit) netting_channel0.deposit(deposit) all_netting_channel_events = get_all_netting_channel_events( app0.raiden.chain, netting_channel_address=netcontract_address, from_block=0, to_block='latest', ) events = get_all_netting_channel_events( app0.raiden.chain, netcontract_address, events=[CONTRACT_MANAGER.get_event_id(EVENT_CHANNEL_NEW_BALANCE)], ) assert len(all_netting_channel_events) == 1 assert len(events) == 1 new_balance_event = { '_event_type': b'ChannelNewBalance', 'token_address': address_encoder(token_address), 'participant': address_encoder(app0.raiden.address), 'balance': deposit, 'block_number': 'ignore', } assert event_dicts_are_equal(all_netting_channel_events[-1], new_balance_event) assert event_dicts_are_equal(events[0], new_balance_event) channel0.external_state.close(None) all_netting_channel_events = get_all_netting_channel_events( app0.raiden.chain, netting_channel_address=netcontract_address, from_block=0, to_block='latest', ) events = get_all_netting_channel_events( app0.raiden.chain, netcontract_address, events=[CONTRACT_MANAGER.get_event_id(EVENT_CHANNEL_CLOSED)], ) assert len(all_netting_channel_events) == 2 assert len(events) == 1 closed_event = { '_event_type': b'ChannelClosed', 'closing_address': address_encoder(app0.raiden.address), 'block_number': 'ignore', } assert event_dicts_are_equal(all_netting_channel_events[-1], closed_event) assert event_dicts_are_equal(events[0], closed_event) settle_expiration = app0.raiden.chain.block_number() + settle_timeout + 1 wait_until_block(app0.raiden.chain, settle_expiration) channel1.external_state.settle() all_netting_channel_events = get_all_netting_channel_events( app0.raiden.chain, netting_channel_address=netcontract_address, from_block=0, to_block='latest', ) events = get_all_netting_channel_events( app0.raiden.chain, netcontract_address, events=[CONTRACT_MANAGER.get_event_id(EVENT_CHANNEL_SETTLED)], ) assert len(all_netting_channel_events) == 3 assert len(events) == 1 settled_event = { '_event_type': b'ChannelSettled', 'block_number': 'ignore', } assert event_dicts_are_equal(all_netting_channel_events[-1], settled_event) assert event_dicts_are_equal(events[0], settled_event)