def get_blockchain_events_token_network( self, token_address: typing.TokenAddress, from_block: typing.BlockSpecification = GENESIS_BLOCK_NUMBER, to_block: typing.BlockSpecification = 'latest', ): """Returns a list of blockchain events coresponding to the token_address.""" if not is_binary_address(token_address): raise InvalidAddress( 'Expected binary address format for token in get_blockchain_events_token_network', ) token_network_address = self.raiden.default_registry.get_token_network( token_address, ) if token_network_address is None: raise UnknownTokenAddress('Token address is not known.') returned_events = blockchain_events.get_token_network_events( chain=self.raiden.chain, token_network_address=token_network_address, contract_manager=self.raiden.contract_manager, events=blockchain_events.ALL_EVENTS, from_block=from_block, to_block=to_block, ) for event in returned_events: if event.get('args'): event['args'] = dict(event['args']) returned_events.sort(key=lambda evt: evt.get('block_number'), reverse=True) return returned_events
def get_blockchain_events_token_network( self, token_address: typing.TokenAddress, from_block: typing.BlockSpecification = 0, to_block: typing.BlockSpecification = 'latest', ): """Returns a list of blockchain events coresponding to the token_address.""" if not is_binary_address(token_address): raise InvalidAddress( 'Expected binary address format for token in get_blockchain_events_token_network', ) token_network_address = self.raiden.default_registry.get_token_network( token_address, ) if token_network_address is None: raise UnknownTokenAddress('Token address is not known.') returned_events = blockchain_events.get_token_network_events( chain=self.raiden.chain, token_network_address=token_network_address, events=blockchain_events.ALL_EVENTS, from_block=from_block, to_block=to_block, ) for event in returned_events: if event.get('args'): event['args'] = dict(event['args']) returned_events.sort(key=lambda evt: evt.get('block_number'), reverse=True) return returned_events
def get_blockchain_events_token_network( self, token_address: TokenAddress, from_block: BlockSpecification = GENESIS_BLOCK_NUMBER, to_block: BlockSpecification = "latest", ): """Returns a list of blockchain events coresponding to the token_address.""" if not is_binary_address(token_address): raise InvalidAddress( "Expected binary address format for token in get_blockchain_events_token_network" ) token_network_address = self.raiden.default_registry.get_token_network(token_address) if token_network_address is None: raise UnknownTokenAddress("Token address is not known.") returned_events = blockchain_events.get_token_network_events( chain=self.raiden.chain, token_network_address=token_network_address, contract_manager=self.raiden.contract_manager, events=blockchain_events.ALL_EVENTS, from_block=from_block, to_block=to_block, ) for event in returned_events: if event.get("args"): event["args"] = dict(event["args"]) returned_events.sort(key=lambda evt: evt.get("block_number"), reverse=True) return returned_events
def get_token_network_events( self, token_address: typing.TokenAddress, from_block: typing.BlockSpecification = 0, to_block: typing.BlockSpecification = 'latest', ): if not is_binary_address(token_address): raise InvalidAddress( 'Expected binary address format for token in get_token_network_events', ) token_network_address = self.raiden.default_registry.get_token_network( token_address, ) if token_network_address is None: raise UnknownTokenAddress('Token address is not known.') returned_events = get_token_network_events( self.raiden.chain, token_network_address, events=ALL_EVENTS, from_block=from_block, to_block=to_block, ) for event in returned_events: if event.get('args'): event['args'] = dict(event['args']) # the channel_identifier is a hash encode_byte_values(event['args']) hexbytes_to_str(event) 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_PAYMENT_HISTORY_RELATED): new_event = { 'block_number': block_number, 'event': type(event).__name__, } new_event.update(event.__dict__) returned_events.append(new_event) returned_events.sort(key=lambda evt: evt.get('block_number'), reverse=True) return returned_events
def get_token_network_events(self, token_address, from_block, to_block='latest'): if not is_binary_address(token_address): raise InvalidAddress( 'Expected binary address format for token in get_token_network_events', ) token_network_address = self.raiden.default_registry.get_token_network( token_address, ) if token_network_address is None: raise UnknownTokenAddress('Token address is not known.') returned_events = get_token_network_events( self.raiden.chain, token_network_address, events=ALL_EVENTS, from_block=from_block, to_block=to_block, ) for event in returned_events: if event.get('args'): event['args'] = dict(event['args']) # the channel_identifier is a hash encode_byte_values(event['args']) hexbytes_to_str(event) 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) returned_events.sort(key=lambda evt: evt.get('block_number'), reverse=True) return returned_events
def test_query_events(raiden_chain, token_addresses, deposit, settle_timeout, retry_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.token_network_by_token( token_address) channelcount0 = views.total_token_network_channels( views.state_from_app(app0), registry_address, token_address, ) events = get_token_network_registry_events( app0.raiden.chain, registry_address, events=ALL_EVENTS, ) assert must_have_event( events, { 'event': EVENT_TOKEN_NETWORK_CREATED, 'args': { 'token_network_address': to_checksum_address(manager0.address), 'token_address': to_checksum_address(token_address), }, }, ) events = get_token_network_registry_events( app0.raiden.chain, app0.raiden.default_registry.address, events=ALL_EVENTS, from_block=999999998, to_block=999999999, ) assert not events RaidenAPI(app0.raiden).channel_open( registry_address, token_address, app1.raiden.address, ) events = get_token_network_events( app0.raiden.chain, manager0.address, events=ALL_EVENTS, ) _event = must_have_event( events, { 'event': EVENT_CHANNEL_OPENED, 'args': { 'participant1': to_checksum_address(app0.raiden.address), 'participant2': to_checksum_address(app1.raiden.address), 'settle_timeout': settle_timeout, }, }, ) assert _event channel_id = _event['args']['channel_identifier'] events = get_token_network_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, ) all_netting_channel_events = get_all_netting_channel_events( app0.raiden.chain, token_network_identifier, channel_id, ) deposit_events = get_netting_channel_deposit_events( app0.raiden.chain, token_network_identifier, channel_id, ) total_deposit_event = { 'event': EVENT_CHANNEL_DEPOSIT, 'args': { 'participant': to_checksum_address(app0.raiden.address), 'total_deposit': deposit, 'channel_identifier': channel_id, }, } assert must_have_event(deposit_events, total_deposit_event) assert must_have_event(all_netting_channel_events, total_deposit_event) RaidenAPI(app0.raiden).channel_close( registry_address, token_address, app1.raiden.address, ) all_netting_channel_events = get_all_netting_channel_events( app0.raiden.chain, token_network_identifier, channel_id, ) closed_events = get_netting_channel_closed_events( app0.raiden.chain, token_network_identifier, channel_id, ) closed_event = { 'event': EVENT_CHANNEL_CLOSED, 'args': { 'channel_identifier': channel_id, 'closing_participant': to_checksum_address(app0.raiden.address), }, } assert must_have_event(closed_events, closed_event) assert must_have_event(all_netting_channel_events, 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, token_network_identifier, channel_id, ) settled_events = get_netting_channel_settled_events( app0.raiden.chain, token_network_identifier, channel_id, ) settled_event = { 'event': EVENT_CHANNEL_SETTLED, 'args': { 'channel_identifier': channel_id, }, } assert must_have_event(settled_events, settled_event) assert must_have_event(all_netting_channel_events, settled_event)
def test_query_events( raiden_chain, token_addresses, deposit, settle_timeout, retry_timeout, contract_manager, blockchain_type, ): app0, app1 = raiden_chain # pylint: disable=unbalanced-tuple-unpacking registry_address = app0.raiden.default_registry.address token_address = token_addresses[0] token_network_address = app0.raiden.default_registry.get_token_network( token_address, BLOCK_ID_LATEST) assert token_network_address manager0 = app0.raiden.proxy_manager.token_network(token_network_address, BLOCK_ID_LATEST) channelcount0 = views.total_token_network_channels( views.state_from_app(app0), registry_address, token_address) events = get_token_network_registry_events( proxy_manager=app0.raiden.proxy_manager, token_network_registry_address=registry_address, contract_manager=contract_manager, events=ALL_EVENTS, ) assert must_have_event( events, { "event": EVENT_TOKEN_NETWORK_CREATED, "args": { "token_network_address": to_checksum_address(manager0.address), "token_address": to_checksum_address(token_address), }, }, ) if blockchain_type == "geth": # FIXME: This is apparently meant to verify that querying nonexisting blocks # returns an empty list, which is not true for parity. events = get_token_network_registry_events( proxy_manager=app0.raiden.proxy_manager, token_network_registry_address=app0.raiden.default_registry. address, contract_manager=contract_manager, events=ALL_EVENTS, from_block=BlockNumber(999999998), to_block=BlockNumber(999999999), ) assert not events RaidenAPI(app0.raiden).channel_open(registry_address, token_address, app1.raiden.address) wait_both_channel_open(app0, app1, registry_address, token_address, retry_timeout) events = get_token_network_events( proxy_manager=app0.raiden.proxy_manager, token_network_address=manager0.address, contract_manager=contract_manager, events=ALL_EVENTS, ) _event = must_have_event( events, { "event": ChannelEvent.OPENED, "args": { "participant1": to_checksum_address(app0.raiden.address), "participant2": to_checksum_address(app1.raiden.address), "settle_timeout": settle_timeout, }, }, ) assert _event channel_id = _event["args"]["channel_identifier"] if blockchain_type == "geth": # see above events = get_token_network_events( proxy_manager=app0.raiden.proxy_manager, token_network_address=manager0.address, contract_manager=contract_manager, events=ALL_EVENTS, from_block=BlockNumber(999999998), to_block=BlockNumber(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_synced_channel_state(token_network_address, app0, Balance(0), [], app1, Balance(0), []) RaidenAPI(app0.raiden).set_total_channel_deposit(registry_address, token_address, app1.raiden.address, deposit) all_netting_channel_events = get_all_netting_channel_events( proxy_manager=app0.raiden.proxy_manager, token_network_address=token_network_address, netting_channel_identifier=channel_id, contract_manager=app0.raiden.contract_manager, ) deposit_events = get_netting_channel_deposit_events( proxy_manager=app0.raiden.proxy_manager, token_network_address=token_network_address, netting_channel_identifier=channel_id, contract_manager=contract_manager, ) total_deposit_event = { "event": ChannelEvent.DEPOSIT, "args": { "participant": to_checksum_address(app0.raiden.address), "total_deposit": deposit, "channel_identifier": channel_id, }, } assert must_have_event(deposit_events, total_deposit_event) assert must_have_event(all_netting_channel_events, total_deposit_event) RaidenAPI(app0.raiden).channel_close(registry_address, token_address, app1.raiden.address) all_netting_channel_events = get_all_netting_channel_events( proxy_manager=app0.raiden.proxy_manager, token_network_address=token_network_address, netting_channel_identifier=channel_id, contract_manager=app0.raiden.contract_manager, ) closed_events = get_netting_channel_closed_events( proxy_manager=app0.raiden.proxy_manager, token_network_address=token_network_address, netting_channel_identifier=channel_id, contract_manager=contract_manager, ) closed_event = { "event": ChannelEvent.CLOSED, "args": { "channel_identifier": channel_id, "closing_participant": to_checksum_address(app0.raiden.address), }, } assert must_have_event(closed_events, closed_event) assert must_have_event(all_netting_channel_events, closed_event) settle_expiration = app0.raiden.rpc_client.block_number( ) + settle_timeout + 5 app0.raiden.proxy_manager.client.wait_until_block( target_block_number=settle_expiration) all_netting_channel_events = get_all_netting_channel_events( proxy_manager=app0.raiden.proxy_manager, token_network_address=token_network_address, netting_channel_identifier=channel_id, contract_manager=app0.raiden.contract_manager, ) settled_events = get_netting_channel_settled_events( proxy_manager=app0.raiden.proxy_manager, token_network_address=token_network_address, netting_channel_identifier=channel_id, contract_manager=contract_manager, ) settled_event = { "event": ChannelEvent.SETTLED, "args": { "channel_identifier": channel_id } } assert must_have_event(settled_events, settled_event) assert must_have_event(all_netting_channel_events, settled_event)
def test_query_events( raiden_chain, token_addresses, deposit, settle_timeout, retry_timeout, contract_manager, blockchain_type, ): 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, ) token_network_address = app0.raiden.default_registry.get_token_network( token_address) manager0 = app0.raiden.chain.token_network(token_network_address) channelcount0 = views.total_token_network_channels( views.state_from_app(app0), registry_address, token_address, ) events = get_token_network_registry_events( chain=app0.raiden.chain, token_network_registry_address=registry_address, contract_manager=contract_manager, events=ALL_EVENTS, ) assert must_have_event( events, { 'event': EVENT_TOKEN_NETWORK_CREATED, 'args': { 'token_network_address': to_checksum_address(manager0.address), 'token_address': to_checksum_address(token_address), }, }, ) if blockchain_type == 'geth': # FIXME: This is apparently meant to verify that querying nonexisting blocks # returns an empty list, which is not true for parity. events = get_token_network_registry_events( chain=app0.raiden.chain, token_network_registry_address=app0.raiden.default_registry. address, contract_manager=contract_manager, events=ALL_EVENTS, from_block=999999998, to_block=999999999, ) assert not events RaidenAPI(app0.raiden).channel_open( registry_address, token_address, app1.raiden.address, ) wait_both_channel_open(app0, app1, registry_address, token_address, retry_timeout) events = get_token_network_events( chain=app0.raiden.chain, token_network_address=manager0.address, contract_manager=contract_manager, events=ALL_EVENTS, ) _event = must_have_event( events, { 'event': ChannelEvent.OPENED, 'args': { 'participant1': to_checksum_address(app0.raiden.address), 'participant2': to_checksum_address(app1.raiden.address), 'settle_timeout': settle_timeout, }, }, ) assert _event channel_id = _event['args']['channel_identifier'] if blockchain_type == 'geth': # see above events = get_token_network_events( chain=app0.raiden.chain, token_network_address=manager0.address, contract_manager=contract_manager, 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_synced_channel_state( token_network_identifier, app0, 0, [], app1, 0, [], ) RaidenAPI(app0.raiden).set_total_channel_deposit( registry_address, token_address, app1.raiden.address, deposit, ) all_netting_channel_events = get_all_netting_channel_events( chain=app0.raiden.chain, token_network_address=token_network_identifier, netting_channel_identifier=channel_id, contract_manager=app0.raiden.contract_manager, ) deposit_events = get_netting_channel_deposit_events( chain=app0.raiden.chain, token_network_address=token_network_identifier, netting_channel_identifier=channel_id, contract_manager=contract_manager, ) total_deposit_event = { 'event': ChannelEvent.DEPOSIT, 'args': { 'participant': to_checksum_address(app0.raiden.address), 'total_deposit': deposit, 'channel_identifier': channel_id, }, } assert must_have_event(deposit_events, total_deposit_event) assert must_have_event(all_netting_channel_events, total_deposit_event) RaidenAPI(app0.raiden).channel_close( registry_address, token_address, app1.raiden.address, ) all_netting_channel_events = get_all_netting_channel_events( chain=app0.raiden.chain, token_network_address=token_network_identifier, netting_channel_identifier=channel_id, contract_manager=app0.raiden.contract_manager, ) closed_events = get_netting_channel_closed_events( chain=app0.raiden.chain, token_network_address=token_network_identifier, netting_channel_identifier=channel_id, contract_manager=contract_manager, ) closed_event = { 'event': ChannelEvent.CLOSED, 'args': { 'channel_identifier': channel_id, 'closing_participant': to_checksum_address(app0.raiden.address), }, } assert must_have_event(closed_events, closed_event) assert must_have_event(all_netting_channel_events, closed_event) settle_expiration = app0.raiden.chain.block_number() + settle_timeout + 5 app0.raiden.chain.wait_until_block(target_block_number=settle_expiration) all_netting_channel_events = get_all_netting_channel_events( chain=app0.raiden.chain, token_network_address=token_network_identifier, netting_channel_identifier=channel_id, contract_manager=app0.raiden.contract_manager, ) settled_events = get_netting_channel_settled_events( chain=app0.raiden.chain, token_network_address=token_network_identifier, netting_channel_identifier=channel_id, contract_manager=contract_manager, ) settled_event = { 'event': ChannelEvent.SETTLED, 'args': { 'channel_identifier': channel_id, }, } assert must_have_event(settled_events, settled_event) assert must_have_event(all_netting_channel_events, settled_event)
def test_query_events( raiden_chain, token_addresses, deposit, settle_timeout, retry_timeout, contract_manager, ): 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, ) token_network_address = app0.raiden.default_registry.get_token_network(token_address) manager0 = app0.raiden.chain.token_network(token_network_address) channelcount0 = views.total_token_network_channels( views.state_from_app(app0), registry_address, token_address, ) events = get_token_network_registry_events( chain=app0.raiden.chain, token_network_registry_address=registry_address, contract_manager=contract_manager, events=ALL_EVENTS, ) assert must_have_event( events, { 'event': EVENT_TOKEN_NETWORK_CREATED, 'args': { 'token_network_address': to_checksum_address(manager0.address), 'token_address': to_checksum_address(token_address), }, }, ) events = get_token_network_registry_events( chain=app0.raiden.chain, token_network_registry_address=app0.raiden.default_registry.address, contract_manager=contract_manager, events=ALL_EVENTS, from_block=999999998, to_block=999999999, ) assert not events RaidenAPI(app0.raiden).channel_open( registry_address, token_address, app1.raiden.address, ) wait_both_channel_open(app0, app1, registry_address, token_address, retry_timeout) events = get_token_network_events( chain=app0.raiden.chain, token_network_address=manager0.address, contract_manager=contract_manager, events=ALL_EVENTS, ) _event = must_have_event( events, { 'event': ChannelEvent.OPENED, 'args': { 'participant1': to_checksum_address(app0.raiden.address), 'participant2': to_checksum_address(app1.raiden.address), 'settle_timeout': settle_timeout, }, }, ) assert _event channel_id = _event['args']['channel_identifier'] events = get_token_network_events( chain=app0.raiden.chain, token_network_address=manager0.address, contract_manager=contract_manager, 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_synced_channel_state( token_network_identifier, app0, 0, [], app1, 0, [], ) RaidenAPI(app0.raiden).set_total_channel_deposit( registry_address, token_address, app1.raiden.address, deposit, ) all_netting_channel_events = get_all_netting_channel_events( chain=app0.raiden.chain, token_network_address=token_network_identifier, netting_channel_identifier=channel_id, contract_manager=app0.raiden.contract_manager, ) deposit_events = get_netting_channel_deposit_events( chain=app0.raiden.chain, token_network_address=token_network_identifier, netting_channel_identifier=channel_id, contract_manager=contract_manager, ) total_deposit_event = { 'event': ChannelEvent.DEPOSIT, 'args': { 'participant': to_checksum_address(app0.raiden.address), 'total_deposit': deposit, 'channel_identifier': channel_id, }, } assert must_have_event(deposit_events, total_deposit_event) assert must_have_event(all_netting_channel_events, total_deposit_event) RaidenAPI(app0.raiden).channel_close( registry_address, token_address, app1.raiden.address, ) all_netting_channel_events = get_all_netting_channel_events( chain=app0.raiden.chain, token_network_address=token_network_identifier, netting_channel_identifier=channel_id, contract_manager=app0.raiden.contract_manager, ) closed_events = get_netting_channel_closed_events( chain=app0.raiden.chain, token_network_address=token_network_identifier, netting_channel_identifier=channel_id, contract_manager=contract_manager, ) closed_event = { 'event': ChannelEvent.CLOSED, 'args': { 'channel_identifier': channel_id, 'closing_participant': to_checksum_address(app0.raiden.address), }, } assert must_have_event(closed_events, closed_event) assert must_have_event(all_netting_channel_events, 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( chain=app0.raiden.chain, token_network_address=token_network_identifier, netting_channel_identifier=channel_id, contract_manager=app0.raiden.contract_manager, ) settled_events = get_netting_channel_settled_events( chain=app0.raiden.chain, token_network_address=token_network_identifier, netting_channel_identifier=channel_id, contract_manager=contract_manager, ) settled_event = { 'event': ChannelEvent.SETTLED, 'args': { 'channel_identifier': channel_id, }, } assert must_have_event(settled_events, settled_event) assert must_have_event(all_netting_channel_events, settled_event)