def get_channel_events( self, token_network_address, channel_identifier, from_block, to_block='latest', ): returned_events = get_all_netting_channel_events( self.raiden.chain, token_network_address, channel_identifier, 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_channel_events(self, channel_address, from_block, to_block='latest'): if not isaddress(channel_address): raise InvalidAddress( 'Expected binary address format for channel in get_channel_events' ) returned_events = get_all_netting_channel_events( self.raiden.chain, channel_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': type(event).__name__.encode(), } new_event.update(event.__dict__) returned_events.append(new_event) return returned_events
def get_blockchain_events_channel( self, token_address: typing.TokenAddress, partner_address: typing.Address = None, from_block: typing.BlockSpecification = GENESIS_BLOCK_NUMBER, to_block: typing.BlockSpecification = 'latest', ): if not is_binary_address(token_address): raise InvalidAddress( 'Expected binary address format for token in get_blockchain_events_channel', ) 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.') channel_list = self.get_channel_list( registry_address=self.raiden.default_registry.address, token_address=token_address, partner_address=partner_address, ) returned_events = [] for channel in channel_list: returned_events.extend(blockchain_events.get_all_netting_channel_events( chain=self.raiden.chain, token_network_address=token_network_address, netting_channel_identifier=channel.identifier, contract_manager=self.raiden.contract_manager, from_block=from_block, to_block=to_block, )) returned_events.sort(key=lambda evt: evt.get('block_number'), reverse=True) return returned_events
def get_blockchain_events_channel( self, token_address: TokenAddress, partner_address: Address = None, from_block: BlockSpecification = GENESIS_BLOCK_NUMBER, to_block: BlockSpecification = "latest", ): if not is_binary_address(token_address): raise InvalidAddress( "Expected binary address format for token in get_blockchain_events_channel" ) 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.") channel_list = self.get_channel_list( registry_address=self.raiden.default_registry.address, token_address=token_address, partner_address=partner_address, ) returned_events = [] for channel in channel_list: returned_events.extend( blockchain_events.get_all_netting_channel_events( chain=self.raiden.chain, token_network_address=token_network_address, netting_channel_identifier=channel.identifier, contract_manager=self.raiden.contract_manager, from_block=from_block, to_block=to_block, ) ) returned_events.sort(key=lambda evt: evt.get("block_number"), reverse=True) return returned_events
def get_channel_events(self, channel_address, from_block, to_block=None): if not isaddress(channel_address): raise InvalidAddress( 'Expected binary address format for channel in get_channel_events' ) returned_events = get_all_netting_channel_events( self.raiden.chain, channel_address, events=ALL_EVENTS, from_block=from_block, to_block=to_block, ) raiden_events = self.raiden.transaction_log.get_events_in_block_range( from_block=from_block, to_block=to_block ) # Here choose which raiden internal events we want to expose to the end user for event in raiden_events: is_user_transfer_event = isinstance(event.event_object, ( EventTransferSentSuccess, EventTransferSentFailed, EventTransferReceivedSuccess )) if is_user_transfer_event: new_event = { 'block_number': event.block_number, '_event_type': type(event.event_object).__name__, } new_event.update(event.event_object.__dict__) returned_events.append(new_event) return returned_events
def get_blockchain_events_channel( self, token_address: typing.TokenAddress, partner_address: typing.Address = None, 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_blockchain_events_channel', ) 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.') channel_list = self.get_channel_list( registry_address=self.raiden.default_registry.address, token_address=token_address, partner_address=partner_address, ) returned_events = [] for channel in channel_list: returned_events.extend( blockchain_events.get_all_netting_channel_events( chain=self.raiden.chain, token_network_address=token_network_address, netting_channel_identifier=channel.identifier, from_block=from_block, to_block=to_block, )) returned_events.sort(key=lambda evt: evt.get('block_number'), reverse=True) return returned_events
def get_channel_events(self, channel_address, from_block, to_block=None): if not isaddress(channel_address): raise InvalidAddress( 'Expected binary address format for channel in get_channel_events' ) returned_events = get_all_netting_channel_events( self.raiden.chain, channel_address, events=ALL_EVENTS, from_block=from_block, to_block=to_block, ) raiden_events = self.raiden.transaction_log.get_events_in_block_range( from_block=from_block, to_block=to_block) # Here choose which raiden internal events we want to expose to the end user for event in raiden_events: is_user_transfer_event = isinstance( event.event_object, (EventTransferSentSuccess, EventTransferSentFailed, EventTransferReceivedSuccess)) if is_user_transfer_event: new_event = { 'block_number': event.block_number, '_event_type': type(event.event_object).__name__, } new_event.update(event.event_object.__dict__) returned_events.append(new_event) return returned_events
def get_channel_events(self, channel_address, from_block, to_block): if not isaddress(channel_address): raise InvalidAddress( 'Expected binary address format for channel in get_channel_events' ) return get_all_netting_channel_events( self.raiden.chain, channel_address, events=ALL_EVENTS, from_block=from_block, to_block=to_block, )
def get_channel_events( self, token_address: typing.Address, partner_address: typing.Address = None, from_block: typing.BlockSpecification = 0, to_block: typing.BlockSpecification = 'latest', ): token_network_address = self.raiden.default_registry.get_token_network( token_address, ) channel_list = self.get_channel_list( registry_address=self.raiden.default_registry.address, token_address=token_address, partner_address=partner_address, ) returned_events = [] for channel in channel_list: returned_events.extend( get_all_netting_channel_events( self.raiden.chain, token_network_address, channel.identifier, 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) returned_events.sort(key=lambda evt: evt.get('block_number'), reverse=True) return returned_events
def get_channel_events( self, token_address: typing.Address, partner_address: typing.Address = None, from_block: typing.BlockSpecification = 0, to_block: typing.BlockSpecification = 'latest', ): token_network_address = self.raiden.default_registry.get_token_network( token_address, ) channel_list = self.get_channel_list( registry_address=self.raiden.default_registry.address, token_address=token_address, partner_address=partner_address, ) returned_events = [] for channel in channel_list: returned_events.extend(get_all_netting_channel_events( self.raiden.chain, token_network_address, channel.identifier, 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) 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, 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, 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)
def test_payment_channel_proxy_basics( token_network_registry_address: TokenNetworkRegistryAddress, token_network_proxy: TokenNetwork, token_proxy: Token, chain_id: ChainID, private_keys: List[PrivateKey], web3: Web3, contract_manager: ContractManager, reveal_timeout: BlockTimeout, ) -> None: token_network_address = token_network_proxy.address partner = privatekey_to_address(private_keys[0]) rpc_client = JSONRPCClient(web3, private_keys[1]) proxy_manager = ProxyManager( rpc_client=rpc_client, contract_manager=contract_manager, metadata=ProxyManagerMetadata( token_network_registry_deployed_at=GENESIS_BLOCK_NUMBER, filters_start_at=GENESIS_BLOCK_NUMBER, ), ) token_network_proxy = proxy_manager.token_network( address=token_network_address, block_identifier=BLOCK_ID_LATEST ) start_block = web3.eth.blockNumber channel_details = token_network_proxy.new_netting_channel( partner=partner, settle_timeout=TEST_SETTLE_TIMEOUT_MIN, given_block_identifier=BLOCK_ID_LATEST, ) channel_identifier = channel_details.channel_identifier assert channel_identifier is not None channel_state = NettingChannelState( canonical_identifier=CanonicalIdentifier( chain_identifier=chain_id, token_network_address=token_network_address, channel_identifier=channel_identifier, ), token_address=token_network_proxy.token_address(), token_network_registry_address=token_network_registry_address, reveal_timeout=reveal_timeout, settle_timeout=BlockTimeout(TEST_SETTLE_TIMEOUT_MIN), fee_schedule=FeeScheduleState(), our_state=NettingChannelEndState( address=token_network_proxy.client.address, contract_balance=Balance(0) ), partner_state=NettingChannelEndState(address=partner, contract_balance=Balance(0)), open_transaction=SuccessfulTransactionState(finished_block_number=BlockNumber(0)), ) channel_proxy_1 = proxy_manager.payment_channel( channel_state=channel_state, block_identifier=BLOCK_ID_LATEST ) assert channel_proxy_1.channel_identifier == channel_identifier assert channel_proxy_1.opened(BLOCK_ID_LATEST) is True # Test deposit initial_token_balance = 100 token_proxy.transfer(rpc_client.address, TokenAmount(initial_token_balance)) assert token_proxy.balance_of(rpc_client.address) == initial_token_balance assert token_proxy.balance_of(partner) == 0 channel_proxy_1.approve_and_set_total_deposit( total_deposit=TokenAmount(10), block_identifier=BLOCK_ID_LATEST ) # ChannelOpened, ChannelNewDeposit channel_events = get_all_netting_channel_events( proxy_manager=proxy_manager, token_network_address=token_network_address, netting_channel_identifier=channel_proxy_1.channel_identifier, contract_manager=contract_manager, from_block=start_block, to_block=web3.eth.blockNumber, ) assert len(channel_events) == 2 block_before_close = web3.eth.blockNumber empty_balance_proof = BalanceProof( channel_identifier=channel_proxy_1.channel_identifier, token_network_address=token_network_address, balance_hash=EMPTY_BALANCE_HASH, nonce=0, chain_id=chain_id, transferred_amount=TokenAmount(0), ) closing_data = ( empty_balance_proof.serialize_bin(msg_type=MessageTypeId.BALANCE_PROOF) + EMPTY_SIGNATURE ) channel_proxy_1.close( nonce=Nonce(0), balance_hash=EMPTY_BALANCE_HASH, additional_hash=EMPTY_MESSAGE_HASH, non_closing_signature=EMPTY_SIGNATURE, closing_signature=LocalSigner(private_keys[1]).sign(data=closing_data), block_identifier=BLOCK_ID_LATEST, ) assert channel_proxy_1.closed(BLOCK_ID_LATEST) is True # ChannelOpened, ChannelNewDeposit, ChannelClosed channel_events = get_all_netting_channel_events( proxy_manager=proxy_manager, token_network_address=token_network_address, netting_channel_identifier=channel_proxy_1.channel_identifier, contract_manager=contract_manager, from_block=start_block, to_block=web3.eth.blockNumber, ) assert len(channel_events) == 3 # check the settlement timeouts again assert channel_proxy_1.settle_timeout() == TEST_SETTLE_TIMEOUT_MIN # update transfer -- we need to wait on +1 since we use the latest block on parity for # estimate gas and at the time the latest block is the settle timeout block. # More info: https://github.com/raiden-network/raiden/pull/3699#discussion_r270477227 rpc_client.wait_until_block( target_block_number=BlockNumber(rpc_client.block_number() + TEST_SETTLE_TIMEOUT_MIN + 1) ) transaction_hash = channel_proxy_1.settle( transferred_amount=TokenAmount(0), locked_amount=LockedAmount(0), locksroot=LOCKSROOT_OF_NO_LOCKS, partner_transferred_amount=TokenAmount(0), partner_locked_amount=LockedAmount(0), partner_locksroot=LOCKSROOT_OF_NO_LOCKS, block_identifier=BLOCK_ID_LATEST, ) assert is_tx_hash_bytes(transaction_hash) assert channel_proxy_1.settled(BLOCK_ID_LATEST) is True # ChannelOpened, ChannelNewDeposit, ChannelClosed, ChannelSettled channel_events = get_all_netting_channel_events( proxy_manager=proxy_manager, token_network_address=token_network_address, netting_channel_identifier=channel_proxy_1.channel_identifier, contract_manager=contract_manager, from_block=start_block, to_block=web3.eth.blockNumber, ) assert len(channel_events) == 4 channel_details = token_network_proxy.new_netting_channel( partner=partner, settle_timeout=TEST_SETTLE_TIMEOUT_MIN, given_block_identifier=BLOCK_ID_LATEST, ) new_channel_identifier = channel_details.channel_identifier assert new_channel_identifier is not None channel_state = NettingChannelState( canonical_identifier=CanonicalIdentifier( chain_identifier=chain_id, token_network_address=token_network_address, channel_identifier=new_channel_identifier, ), token_address=token_network_proxy.token_address(), token_network_registry_address=token_network_registry_address, reveal_timeout=reveal_timeout, settle_timeout=BlockTimeout(TEST_SETTLE_TIMEOUT_MIN), fee_schedule=FeeScheduleState(), our_state=NettingChannelEndState( address=token_network_proxy.client.address, contract_balance=Balance(0) ), partner_state=NettingChannelEndState(address=partner, contract_balance=Balance(0)), open_transaction=SuccessfulTransactionState(finished_block_number=BlockNumber(0)), ) channel_proxy_2 = proxy_manager.payment_channel( channel_state=channel_state, block_identifier=BLOCK_ID_LATEST ) assert channel_proxy_2.channel_identifier == new_channel_identifier assert channel_proxy_2.opened(BLOCK_ID_LATEST) is True msg = "The channel was already closed, the second call must fail" with pytest.raises(RaidenRecoverableError): channel_proxy_1.close( nonce=Nonce(0), balance_hash=EMPTY_BALANCE_HASH, additional_hash=EMPTY_MESSAGE_HASH, non_closing_signature=EMPTY_SIGNATURE, closing_signature=LocalSigner(private_keys[1]).sign(data=closing_data), block_identifier=block_before_close, ) pytest.fail(msg) msg = "The channel is not open at latest, this must raise" with pytest.raises(RaidenUnrecoverableError): channel_proxy_1.close( nonce=Nonce(0), balance_hash=EMPTY_BALANCE_HASH, additional_hash=EMPTY_MESSAGE_HASH, non_closing_signature=EMPTY_SIGNATURE, closing_signature=LocalSigner(private_keys[1]).sign(data=closing_data), block_identifier=BLOCK_ID_LATEST, ) pytest.fail(msg) msg = ( "The channel was not opened at the provided block (latest). " "This call should never have been attempted." ) with pytest.raises(BrokenPreconditionError): channel_proxy_1.approve_and_set_total_deposit( total_deposit=TokenAmount(20), block_identifier=BLOCK_ID_LATEST ) pytest.fail(msg)
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)