def test_event_transfer_received_success(token_addresses, raiden_chain): app0, app1, app2, receiver_app = raiden_chain token_address = token_addresses[0] start_block = receiver_app.raiden.get_block_number() expected = dict() for num, app in enumerate([app0, app1, app2]): amount = 1 + num transfer_event = RaidenAPI(app.raiden).transfer_async( token_address, amount, receiver_app.raiden.address, ) transfer_event.wait(timeout=20) expected[app.raiden.address] = amount initiators = list() received = list() events = get_channel_events_for_token(receiver_app, token_address, start_block) for event in events: if event['_event_type'] == 'EventTransferReceivedSuccess': received.append(event) initiators.append(event['initiator']) assert len(received) == 3 assert len(initiators) == 3 without_receiver_app = [ app0.raiden.address, app1.raiden.address, app2.raiden.address ] assert set(without_receiver_app) == set(initiators) for event in received: assert expected[event['initiator']] == event['amount']
def test_event_transfer_received_success(token_addresses, raiden_chain): app0, app1, app2, receiver_app = raiden_chain token_address = token_addresses[0] expected = dict() for num, app in enumerate([app0, app1, app2]): amount = 1 + num transfer_event = RaidenAPI(app.raiden).transfer_async( app.raiden.default_registry.address, token_address, amount, receiver_app.raiden.address, ) transfer_event.wait(timeout=20) expected[app.raiden.address] = amount # sleep is for the receiver's node to have time to process all events gevent.sleep(1) events = receiver_app.raiden.wal.storage.get_events_by_block(0, 'latest') events = [e[1] for e in events] assert must_contain_entry(events, EventTransferReceivedSuccess, { 'amount': 1, 'initiator': app0.raiden.address }) assert must_contain_entry(events, EventTransferReceivedSuccess, { 'amount': 2, 'initiator': app1.raiden.address }) assert must_contain_entry(events, EventTransferReceivedSuccess, { 'amount': 3, 'initiator': app2.raiden.address })
def test_echo_node_response(token_addresses, raiden_chain, network_wait): app0, app1, app2, echo_app = raiden_chain address_to_app = {app.raiden.address: app for app in raiden_chain} token_address = token_addresses[0] echo_api = RaidenAPI(echo_app.raiden) echo_node = EchoNode(echo_api, token_address) echo_node.ready.wait(timeout=30) assert echo_node.ready.is_set() expected = list() # Create some transfers for num, app in enumerate([app0, app1, app2]): amount = 1 + num transfer_event = RaidenAPI(app.raiden).transfer_async( app.raiden.default_registry.address, token_address, amount, echo_app.raiden.address, 10 ** (num + 1), ) transfer_event.wait(timeout=20) expected.append(amount) while echo_node.num_handled_transfers < len(expected): gevent.sleep(.5) # Check that all transfers were handled correctly def test_events(handled_transfer): app = address_to_app[handled_transfer.initiator] events = RaidenAPI(app.raiden).get_raiden_events_payment_history( token_address=token_address, ) received = { event.identifier: event for event in events if type(event) == EventPaymentReceivedSuccess } if len(received) != 1: return transfer = received.popitem()[1] is_not_valid = ( transfer.initiator != echo_app.raiden.address or transfer.identifier != handled_transfer.identifier + transfer.amount ) if is_not_valid: return return transfer for handled_transfer in echo_node.seen_transfers: assert wait_until(lambda: test_events(handled_transfer), network_wait) echo_node.stop()
def test_echo_node_response(token_addresses, raiden_chain, network_wait): app0, app1, app2, echo_app = raiden_chain address_to_app = {app.raiden.address: app for app in raiden_chain} token_address = token_addresses[0] echo_api = RaidenAPI(echo_app.raiden) echo_node = EchoNode(echo_api, token_address) echo_node.ready.wait(timeout=30) assert echo_node.ready.is_set() expected = list() # Create some transfers for num, app in enumerate([app0, app1, app2]): amount = 1 + num transfer_event = RaidenAPI(app.raiden).transfer_async( app.raiden.default_registry.address, token_address, amount, echo_app.raiden.address, 10**(num + 1), ) transfer_event.wait(timeout=20) expected.append(amount) while echo_node.num_handled_transfers < len(expected): gevent.sleep(.5) # Check that all transfers were handled correctly def test_events(handled_transfer): app = address_to_app[handled_transfer.initiator] events = RaidenAPI( app.raiden).get_payment_history_for_token(token_address) received = { event.identifier: event for _, event in events if type(event) == EventPaymentReceivedSuccess } if len(received) != 1: return transfer = received.popitem()[1] is_not_valid = (transfer.initiator != echo_app.raiden.address or transfer.identifier != handled_transfer.identifier + transfer.amount) if is_not_valid: return return transfer for handled_transfer in echo_node.seen_transfers: assert wait_until(lambda: test_events(handled_transfer), network_wait) echo_node.stop()
def test_echo_node_response(token_addresses, raiden_chain, network_wait): app0, app1, app2, echo_app = raiden_chain address_to_app = {app.raiden.address: app for app in raiden_chain} token_address = token_addresses[0] echo_api = RaidenAPI(echo_app.raiden) echo_node = EchoNode(echo_api, token_address) echo_node.ready.wait(timeout=30) assert echo_node.ready.is_set() expected = list() # Create some transfers for num, app in enumerate([app0, app1, app2]): amount = 1 + num transfer_event = RaidenAPI(app.raiden).transfer_async( app.raiden.default_registry.address, token_address, amount, echo_app.raiden.address, 10**(num + 1), ) transfer_event.wait(timeout=20) expected.append(amount) while echo_node.num_handled_transfers < len(expected): gevent.sleep(.5) # Check that all transfers were handled correctly def test_events(handled_transfer): app = address_to_app[handled_transfer['initiator']] events = get_channel_events_for_token( app, app.raiden.default_registry.address, token_address, 0, ) received = { event['identifier']: event for event in events if event['event'] == 'EventTransferReceivedSuccess' } if len(received) != 1: return transfer = received.popitem()[1] if (transfer['initiator'] != echo_app.raiden.address or transfer['identifier'] != handled_transfer['identifier'] + transfer['amount']): return return transfer for handled_transfer in echo_node.seen_transfers: assert wait_until(lambda: test_events(handled_transfer), network_wait) echo_node.stop()
def test_token_swap(raiden_network, deposit, settle_timeout): app0, app1 = raiden_network maker_address = app0.raiden.address taker_address = app1.raiden.address maker_token, taker_token = app0.raiden.channelgraphs.keys()[:2] maker_amount = 70 taker_amount = 30 identifier = 313 RaidenAPI(app1.raiden).expect_token_swap( identifier, maker_token, maker_amount, maker_address, taker_token, taker_amount, taker_address, ) async_result = RaidenAPI(app0.raiden).token_swap_async( identifier, maker_token, maker_amount, maker_address, taker_token, taker_amount, taker_address, ) async_result.wait() # wait for the taker to receive and process the messages gevent.sleep(0.5) assert_synched_channels( channel(app0, app1, maker_token), deposit - maker_amount, [], channel(app1, app0, maker_token), deposit + maker_amount, [], ) assert_synched_channels( channel(app0, app1, taker_token), deposit + taker_amount, [], channel(app1, app0, taker_token), deposit - taker_amount, [], )
def test_echo_node_response(token_addresses, raiden_chain): app0, app1, app2, echo_app = raiden_chain address_to_app = {app.raiden.address: app for app in raiden_chain} token_address = token_addresses[0] echo_api = RaidenAPI(echo_app.raiden) echo_node = EchoNode(echo_api, token_address) echo_node.ready.wait(timeout=30) assert echo_node.ready.is_set() expected = list() # Create some transfers for num, app in enumerate([app0, app1, app2]): amount = 1 + num transfer_event = RaidenAPI(app.raiden).transfer_async( app.raiden.default_registry.address, token_address, amount, echo_app.raiden.address, 10**(num + 1), ) transfer_event.wait(timeout=20) expected.append(amount) while echo_node.num_handled_transfers < len(expected): gevent.sleep(.5) # Check that all transfers were handled correctly for handled_transfer in echo_node.seen_transfers: app = address_to_app[handled_transfer['initiator']] events = get_channel_events_for_token( app.raiden.default_registry.address, app, token_address, 0, ) received = {} for event in events: if event['event'] == 'EventTransferReceivedSuccess': received[repr(event)] = event assert len(received) == 1 transfer = list(received.values())[0] assert transfer['initiator'] == echo_app.raiden.address assert transfer['identifier'] == (handled_transfer['identifier'] + transfer['amount']) echo_node.stop()
def test_echo_node_response(token_addresses, raiden_chain): app0, app1, app2, echo_app = raiden_chain address_to_app = {app.raiden.address: app for app in raiden_chain} token_address = token_addresses[0] echo_api = RaidenAPI(echo_app.raiden) echo_node = EchoNode(echo_api, token_address) echo_node.ready.wait(timeout=30) assert echo_node.ready.is_set() expected = list() # Create some transfers for num, app in enumerate([app0, app1, app2]): amount = 1 + num transfer_event = RaidenAPI(app.raiden).transfer_async( token_address, amount, echo_app.raiden.address, 10 ** (num + 1) ) transfer_event.wait(timeout=20) expected.append(amount) while echo_node.num_handled_transfers < len(expected): gevent.sleep(.5) # Check that all transfers were handled correctly for handled_transfer in echo_node.seen_transfers: app = address_to_app[handled_transfer['initiator']] events = get_channel_events_for_token(app, token_address, 0) received = {} for event in events: if event['_event_type'] == 'EventTransferReceivedSuccess': received[repr(event)] = event assert len(received) == 1 transfer = list(received.values())[0] assert transfer['initiator'] == echo_app.raiden.address assert transfer['identifier'] == ( handled_transfer['identifier'] + transfer['amount'] ) echo_node.stop()
def test_event_transfer_received_success( token_addresses, raiden_chain, network_wait, skip_if_not_udp, ): app0, app1, app2, receiver_app = raiden_chain token_address = token_addresses[0] expected = dict() for num, app in enumerate([app0, app1, app2]): amount = 1 + num transfer_event = RaidenAPI(app.raiden).transfer_async( app.raiden.default_registry.address, token_address, amount, receiver_app.raiden.address, ) transfer_event.wait(timeout=20) expected[app.raiden.address] = amount # sleep is for the receiver's node to have time to process all events gevent.sleep(1) def test_events(amount, address): events = receiver_app.raiden.wal.storage.get_events_by_block( 0, 'latest') events = [e[1] for e in events] return must_contain_entry( events, EventTransferReceivedSuccess, { 'amount': amount, 'initiator': address }, ) amounts = [1, 2, 3] addrs = [app0.raiden.address, app1.raiden.address, app2.raiden.address] for amount, address in zip(amounts, addrs): assert wait_until( lambda: test_events(amount, address), network_wait, )
def test_token_swap(raiden_network, deposit, token_addresses): app0, app1 = raiden_network maker_address = app0.raiden.address taker_address = app1.raiden.address maker_token, taker_token = token_addresses[0], token_addresses[1] maker_amount = 70 taker_amount = 30 identifier = 313 RaidenAPI(app1.raiden).expect_token_swap( # pylint: disable=no-member identifier, maker_token, maker_amount, maker_address, taker_token, taker_amount, taker_address, ) async_result = RaidenAPI(app0.raiden).token_swap_async( # pylint: disable=no-member identifier, maker_token, maker_amount, maker_address, taker_token, taker_amount, taker_address, ) assert async_result.wait() # wait for the taker to receive and process the messages gevent.sleep(0.5) assert_synced_channel_state( maker_token, app0, deposit - maker_amount, [], app1, deposit + maker_amount, [], ) assert_synced_channel_state( taker_token, app0, deposit + taker_amount, [], app1, deposit - taker_amount, [], )
def test_event_transfer_received_success( token_addresses, raiden_chain, network_wait, ): app0, app1, app2, receiver_app = raiden_chain token_address = token_addresses[0] expected = dict() for num, app in enumerate([app0, app1, app2]): amount = 1 + num transfer_event = RaidenAPI(app.raiden).transfer_async( app.raiden.default_registry.address, token_address, amount, receiver_app.raiden.address, ) transfer_event.wait(timeout=20) expected[app.raiden.address] = amount # sleep is for the receiver's node to have time to process all events gevent.sleep(1) def test_events(amount, address): return search_for_item( receiver_app.raiden.wal.storage.get_events(), EventPaymentReceivedSuccess, { 'amount': amount, 'initiator': address }, ) amounts = [1, 2, 3] addrs = [app0.raiden.address, app1.raiden.address, app2.raiden.address] for amount, address in zip(amounts, addrs): assert wait_until( lambda: test_events(amount, address), network_wait, )
def test_event_transfer_received_success(token_addresses, raiden_chain): app0, app1, app2, receiver_app = raiden_chain token_address = token_addresses[0] start_block = receiver_app.raiden.get_block_number() expected = dict() for num, app in enumerate([app0, app1, app2]): amount = 1 + num transfer_event = RaidenAPI(app.raiden).transfer_async( token_address, amount, receiver_app.raiden.address, ) transfer_event.wait(timeout=20) expected[app.raiden.address] = amount events = get_channel_events_for_token( receiver_app, token_address, start_block, ) transfer_initiators = list() events_received = list() for event in events: if event['_event_type'] == 'EventTransferReceivedSuccess': events_received.append(event) transfer_initiators.append(event['initiator']) assert expected[event['initiator']] == event['amount'] assert len(events_received) == len(expected), '# of events must be equal to # of transfers' without_receiver_app = [ app0.raiden.address, app1.raiden.address, app2.raiden.address, ] assert set(without_receiver_app) == set(transfer_initiators)
def test_event_transfer_received_success( token_addresses, raiden_chain, network_wait, ): app0, app1, app2, receiver_app = raiden_chain token_address = token_addresses[0] expected = dict() for num, app in enumerate([app0, app1, app2]): amount = 1 + num transfer_event = RaidenAPI(app.raiden).transfer_async( app.raiden.default_registry.address, token_address, amount, receiver_app.raiden.address, ) transfer_event.wait(timeout=20) expected[app.raiden.address] = amount # sleep is for the receiver's node to have time to process all events gevent.sleep(1) def test_events(amount, address): return must_contain_entry( receiver_app.raiden.wal.storage.get_events(), EventPaymentReceivedSuccess, {'amount': amount, 'initiator': address}, ) amounts = [1, 2, 3] addrs = [app0.raiden.address, app1.raiden.address, app2.raiden.address] for amount, address in zip(amounts, addrs): assert wait_until( lambda: test_events(amount, address), network_wait, )
def test_token_swap(raiden_network, deposit, settle_timeout): app0, app1 = raiden_network maker_address = app0.raiden.address taker_address = app1.raiden.address maker_token, taker_token = list(app0.raiden.token_to_channelgraph.keys())[:2] maker_amount = 70 taker_amount = 30 identifier = 313 RaidenAPI(app1.raiden).expect_token_swap( identifier, maker_token, maker_amount, maker_address, taker_token, taker_amount, taker_address, ) async_result = RaidenAPI(app0.raiden).token_swap_async( identifier, maker_token, maker_amount, maker_address, taker_token, taker_amount, taker_address, ) assert async_result.wait() # wait for the taker to receive and process the messages gevent.sleep(0.5) assert_synched_channels( channel(app0, app1, maker_token), deposit - maker_amount, [], channel(app1, app0, maker_token), deposit + maker_amount, [], ) assert_synched_channels( channel(app0, app1, taker_token), deposit + taker_amount, [], channel(app1, app0, taker_token), deposit - taker_amount, [], )
def test_transfer_to_unknownchannel(raiden_network): app0, app1 = raiden_network # pylint: disable=unbalanced-tuple-unpacking graph0 = app0.raiden.channelgraphs.values()[0] graph1 = app1.raiden.channelgraphs.values()[0] assert graph0.token_address == graph1.token_address assert app1.raiden.address in graph0.partneraddress_channel with pytest.raises(NoPathError): result = RaidenAPI(app0.raiden).transfer( graph0.token_address, 10, # sending to an unknown/non-existant address target= '\xf0\xef3\x01\xcd\xcfe\x0f4\x9c\xf6d\xa2\x01?X4\x84\xa9\xf1', ) assert result.wait(timeout=10)
def test_echo_node_lottery(token_addresses, raiden_chain): app0, app1, app2, app3, echo_app, app4, app5, app6 = raiden_chain address_to_app = {app.raiden.address: app for app in raiden_chain} token_address = token_addresses[0] echo_api = RaidenAPI(echo_app.raiden) echo_node = EchoNode(echo_api, token_address) echo_node.ready.wait(timeout=30) assert echo_node.ready.is_set() expected = list() # Let 6 participants enter the pool amount = 7 for num, app in enumerate([app0, app1, app2, app3, app4, app5]): transfer_event = RaidenAPI(app.raiden).transfer_async( token_address, amount, echo_app.raiden.address, 10**(num + 1)) transfer_event.wait(timeout=20) expected.append(amount) # test duplicated identifier + amount is ignored transfer_event = RaidenAPI(app5.raiden).transfer_async( token_address, amount, # same amount as before echo_app.raiden.address, 10**6 # app5 used this identifier before ).wait(timeout=20) # test pool size querying pool_query_identifier = 77 # unused identifier different from previous one transfer_event = RaidenAPI(app5.raiden).transfer_async( token_address, amount, echo_app.raiden.address, pool_query_identifier).wait(timeout=20) expected.append(amount) # fill the pool transfer_event = RaidenAPI(app6.raiden).transfer_async( token_address, amount, echo_app.raiden.address, 10**7).wait(timeout=20) expected.append(amount) while echo_node.num_handled_transfers < len(expected): gevent.sleep(.5) received = {} # Check that payout was generated and pool_size_query answered for handled_transfer in echo_node.seen_transfers: app = address_to_app[handled_transfer['initiator']] events = get_channel_events_for_token(app, token_address, 0) for event in events: if event['_event_type'] == 'EventTransferReceivedSuccess': received[repr(event)] = event assert len(received) == 2 received = sorted(received.values(), key=lambda transfer: transfer['amount']) pool_query = received[0] assert pool_query['amount'] == 6 assert pool_query['identifier'] == pool_query_identifier + 6 winning_transfer = received[1] assert winning_transfer['initiator'] == echo_app.raiden.address assert winning_transfer['amount'] == 49 assert (winning_transfer['identifier'] - 49) % 10 == 0 echo_node.stop()
def test_echo_node_lottery(token_addresses, raiden_chain, network_wait): app0, app1, app2, app3, echo_app, app4, app5, app6 = raiden_chain address_to_app = {app.raiden.address: app for app in raiden_chain} token_address = token_addresses[0] echo_api = RaidenAPI(echo_app.raiden) echo_node = EchoNode(echo_api, token_address) echo_node.ready.wait(timeout=30) assert echo_node.ready.is_set() expected = list() # Let 6 participants enter the pool amount = 7 for num, app in enumerate([app0, app1, app2, app3, app4, app5]): transfer_event = RaidenAPI(app.raiden).transfer_async( app.raiden.default_registry.address, token_address, amount, echo_app.raiden.address, 10**(num + 1), ) transfer_event.wait(timeout=20) expected.append(amount) # test duplicated identifier + amount is ignored transfer_event = RaidenAPI(app5.raiden).transfer_async( app.raiden.default_registry.address, token_address, amount, # same amount as before echo_app.raiden.address, 10**6, # app5 used this identifier before ).wait(timeout=20) # test pool size querying pool_query_identifier = 77 # unused identifier different from previous one transfer_event = RaidenAPI(app5.raiden).transfer_async( app.raiden.default_registry.address, token_address, amount, echo_app.raiden.address, pool_query_identifier, ).wait(timeout=20) expected.append(amount) # fill the pool transfer_event = RaidenAPI(app6.raiden).transfer_async( app.raiden.default_registry.address, token_address, amount, echo_app.raiden.address, 10**7, ).wait(timeout=20) expected.append(amount) while echo_node.num_handled_transfers < len(expected): gevent.sleep(.5) def get_echoed_transfer(sent_transfer): """For a given transfer sent to echo node, get the corresponding echoed transfer""" app = address_to_app[sent_transfer.initiator] events = RaidenAPI(app.raiden).get_raiden_events_payment_history( token_address=token_address, ) def is_valid(event): return (type(event) == EventPaymentReceivedSuccess and event.initiator == echo_app.raiden.address and event.identifier == sent_transfer.identifier + event.amount) received = { event.identifier: event for event in events if is_valid(event) } if len(received) != 1: return return received.popitem()[1] def received_is_of_size(size): """Return transfers received from echo_node when there's size transfers""" received = {} # Check that payout was generated and pool_size_query answered for handled_transfer in echo_node.seen_transfers: event = get_echoed_transfer(handled_transfer) if not event: continue received[event.identifier] = event if len(received) == size: return received # wait for the expected echoed transfers to be handled received = wait_until(lambda: received_is_of_size(2), 2 * network_wait) assert received received = sorted(received.values(), key=lambda transfer: transfer.amount) pool_query = received[0] assert pool_query.amount == 6 assert pool_query.identifier == pool_query_identifier + 6 winning_transfer = received[1] assert winning_transfer.initiator == echo_app.raiden.address assert winning_transfer.amount == 49 assert (winning_transfer.identifier - 49) % 10 == 0 echo_node.stop()
def test_echo_node_lottery(token_addresses, raiden_chain, network_wait): app0, app1, app2, app3, echo_app, app4, app5, app6 = raiden_chain address_to_app = {app.raiden.address: app for app in raiden_chain} token_address = token_addresses[0] echo_api = RaidenAPI(echo_app.raiden) echo_node = EchoNode(echo_api, token_address) echo_node.ready.wait(timeout=30) assert echo_node.ready.is_set() expected = list() # Let 6 participants enter the pool amount = 7 for num, app in enumerate([app0, app1, app2, app3, app4, app5]): transfer_event = RaidenAPI(app.raiden).transfer_async( app.raiden.default_registry.address, token_address, amount, echo_app.raiden.address, 10 ** (num + 1), ) transfer_event.wait(timeout=20) expected.append(amount) # test duplicated identifier + amount is ignored transfer_event = RaidenAPI(app5.raiden).transfer_async( app.raiden.default_registry.address, token_address, amount, # same amount as before echo_app.raiden.address, 10 ** 6, # app5 used this identifier before ).wait(timeout=20) # test pool size querying pool_query_identifier = 77 # unused identifier different from previous one transfer_event = RaidenAPI(app5.raiden).transfer_async( app.raiden.default_registry.address, token_address, amount, echo_app.raiden.address, pool_query_identifier, ).wait(timeout=20) expected.append(amount) # fill the pool transfer_event = RaidenAPI(app6.raiden).transfer_async( app.raiden.default_registry.address, token_address, amount, echo_app.raiden.address, 10 ** 7, ).wait(timeout=20) expected.append(amount) while echo_node.num_handled_transfers < len(expected): gevent.sleep(.5) def get_echoed_transfer(sent_transfer): """For a given transfer sent to echo node, get the corresponding echoed transfer""" app = address_to_app[sent_transfer.initiator] events = RaidenAPI(app.raiden).get_raiden_events_payment_history( token_address=token_address, ) def is_valid(event): return ( type(event) == EventPaymentReceivedSuccess and event.initiator == echo_app.raiden.address and event.identifier == sent_transfer.identifier + event.amount ) received = { event.identifier: event for event in events if is_valid(event) } if len(received) != 1: return return received.popitem()[1] def received_is_of_size(size): """Return transfers received from echo_node when there's size transfers""" received = {} # Check that payout was generated and pool_size_query answered for handled_transfer in echo_node.seen_transfers: event = get_echoed_transfer(handled_transfer) if not event: continue received[event.identifier] = event if len(received) == size: return received # wait for the expected echoed transfers to be handled received = wait_until(lambda: received_is_of_size(2), 2 * network_wait) assert received received = sorted(received.values(), key=lambda transfer: transfer.amount) pool_query = received[0] assert pool_query.amount == 6 assert pool_query.identifier == pool_query_identifier + 6 winning_transfer = received[1] assert winning_transfer.initiator == echo_app.raiden.address assert winning_transfer.amount == 49 assert (winning_transfer.identifier - 49) % 10 == 0 echo_node.stop()
def test_echo_node_lottery(token_addresses, raiden_chain): app0, app1, app2, app3, echo_app, app4, app5, app6 = raiden_chain address_to_app = {app.raiden.address: app for app in raiden_chain} token_address = token_addresses[0] echo_api = RaidenAPI(echo_app.raiden) echo_node = EchoNode(echo_api, token_address) echo_node.ready.wait(timeout=30) assert echo_node.ready.is_set() expected = list() # Let 6 participants enter the pool amount = 7 for num, app in enumerate([app0, app1, app2, app3, app4, app5]): transfer_event = RaidenAPI(app.raiden).transfer_async( token_address, amount, echo_app.raiden.address, 10 ** (num + 1) ) transfer_event.wait(timeout=20) expected.append(amount) # test duplicated identifier + amount is ignored transfer_event = RaidenAPI(app5.raiden).transfer_async( token_address, amount, # same amount as before echo_app.raiden.address, 10 ** 6 # app5 used this identifier before ).wait(timeout=20) # test pool size querying pool_query_identifier = 77 # unused identifier different from previous one transfer_event = RaidenAPI(app5.raiden).transfer_async( token_address, amount, echo_app.raiden.address, pool_query_identifier ).wait(timeout=20) expected.append(amount) # fill the pool transfer_event = RaidenAPI(app6.raiden).transfer_async( token_address, amount, echo_app.raiden.address, 10 ** 7 ).wait(timeout=20) expected.append(amount) while echo_node.num_handled_transfers < len(expected): gevent.sleep(.5) received = {} # Check that payout was generated and pool_size_query answered for handled_transfer in echo_node.seen_transfers: app = address_to_app[handled_transfer['initiator']] events = get_channel_events_for_token(app, token_address, 0) for event in events: if event['_event_type'] == 'EventTransferReceivedSuccess': received[repr(event)] = event assert len(received) == 2 received = sorted(received.values(), key=lambda transfer: transfer['amount']) pool_query = received[0] assert pool_query['amount'] == 6 assert pool_query['identifier'] == pool_query_identifier + 6 winning_transfer = received[1] assert winning_transfer['initiator'] == echo_app.raiden.address assert winning_transfer['amount'] == 49 assert (winning_transfer['identifier'] - 49) % 10 == 0 echo_node.stop()