def test_total_token_network_channels(): number_of_channels = 3 test_state = factories.make_chain_state( number_of_channels=number_of_channels) unknown_token_address = factories.make_address() unknown_token_network_registry_address = factories.make_address() assert (views.total_token_network_channels( chain_state=test_state.chain_state, token_network_registry_address=unknown_token_network_registry_address, token_address=unknown_token_address, ) == 0) assert (views.total_token_network_channels( chain_state=test_state.chain_state, token_network_registry_address=unknown_token_network_registry_address, token_address=test_state.token_address, ) == 0) assert (views.total_token_network_channels( chain_state=test_state.chain_state, token_network_registry_address=test_state. token_network_registry_address, token_address=unknown_token_address, ) == 0) assert (views.total_token_network_channels( chain_state=test_state.chain_state, token_network_registry_address=test_state. token_network_registry_address, token_address=test_state.token_address, ) == number_of_channels)
def test_channel_new(raiden_chain, retry_timeout, token_addresses): app0, app1 = raiden_chain # pylint: disable=unbalanced-tuple-unpacking registry_address = app0.raiden.default_registry.address token_address = token_addresses[0] channelcount0 = views.total_token_network_channels( views.state_from_app(app0), registry_address, token_address, ) RaidenAPI(app0.raiden).channel_open( registry_address, token_address, app1.raiden.address, ) gevent.sleep(retry_timeout) # The channel is created but without funds channelcount1 = views.total_token_network_channels( views.state_from_app(app0), registry_address, token_address, ) assert channelcount0 + 1 == channelcount1
def test_channel_new(raiden_chain, retry_timeout, token_addresses): app0, app1 = raiden_chain # pylint: disable=unbalanced-tuple-unpacking registry_address = app0.raiden.default_registry.address token_address = token_addresses[0] channelcount0 = views.total_token_network_channels( views.state_from_app(app0), registry_address, token_address, ) RaidenAPI(app0.raiden).channel_open( registry_address, token_address, app1.raiden.address, ) wait_both_channel_open(app0, app1, registry_address, token_address, retry_timeout) # The channel is created but without funds channelcount1 = views.total_token_network_channels( views.state_from_app(app0), registry_address, token_address, ) assert channelcount0 + 1 == channelcount1
def test_channel_new(raiden_chain: List[RaidenService], retry_timeout, token_addresses): app0, app1 = raiden_chain # pylint: disable=unbalanced-tuple-unpacking registry_address = app0.default_registry.address token_address = token_addresses[0] channelcount0 = views.total_token_network_channels( views.state_from_raiden(app0), registry_address, token_address) RaidenAPI(app0).channel_open(registry_address, token_address, app1.address) wait_both_channel_open(app0, app1, registry_address, token_address, retry_timeout) # The channel is created but without funds channelcount1 = views.total_token_network_channels( views.state_from_raiden(app0), registry_address, token_address) assert channelcount0 + 1 == channelcount1
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, 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)