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, 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_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()
