def api_server_test_instance(raiden_network: List[RaidenService]) -> APIServer:
api_server = prepare_api_server(raiden_network[0])
return api_server
def test_payment_events_endpoints(api_server_test_instance: APIServer,
raiden_network: List[RaidenService],
token_addresses):
app0, app1, app2 = raiden_network
token_address0 = token_addresses[0]
token_address1 = token_addresses[1]
app0_server = api_server_test_instance
app1_server = prepare_api_server(app1)
app2_server = prepare_api_server(app2)
# Payment 1: app0 is sending tokens of token0 to app1
identifier1 = PaymentID(10)
amount1 = PaymentAmount(10)
secret1, secrethash1 = factories.make_secret_with_hash()
request = grequests.post(
api_url_for(
app0_server,
"token_target_paymentresource",
token_address=to_checksum_address(token_address0),
target_address=to_checksum_address(app1.address),
),
json={
"amount": str(amount1),
"identifier": str(identifier1),
"secret": to_hex(secret1)
},
)
request.send()
# Payment 2: app0 is sending some tokens of token1 to app2
identifier2 = PaymentID(20)
amount2 = PaymentAmount(10)
secret2, secrethash2 = factories.make_secret_with_hash()
request = grequests.post(
api_url_for(
app0_server,
"token_target_paymentresource",
token_address=to_checksum_address(token_address1),
target_address=to_checksum_address(app2.address),
),
json={
"amount": str(amount2),
"identifier": str(identifier2),
"secret": to_hex(secret2)
},
)
request.send()
# Payment 3: app0 is sending some tokens of token0 to app2
identifier3 = PaymentID(30)
amount3 = PaymentAmount(17)
secret3, secrethash3 = factories.make_secret_with_hash()
request = grequests.post(
api_url_for(
app0_server,
"token_target_paymentresource",
token_address=to_checksum_address(token_address0),
target_address=to_checksum_address(app1.address),
),
json={
"amount": str(amount3),
"identifier": str(identifier3),
"secret": to_hex(secret3)
},
)
request.send()
timeout = block_offset_timeout(
app2, "Waiting for transfer received success in the WAL timed out")
with watch_for_unlock_failures(*raiden_network), timeout:
result = wait_for_received_transfer_result(app1, identifier1, amount1,
app1.alarm.sleep_time,
secrethash1)
msg = f"Unexpected transfer result: {str(result)}"
assert result == TransferWaitResult.UNLOCKED, msg
result = wait_for_received_transfer_result(app2, identifier2, amount2,
app2.alarm.sleep_time,
secrethash2)
msg = f"Unexpected transfer result: {str(result)}"
assert result == TransferWaitResult.UNLOCKED, msg
result = wait_for_received_transfer_result(app1, identifier3, amount3,
app1.alarm.sleep_time,
secrethash3)
msg = f"Unexpected transfer result: {str(result)}"
assert result == TransferWaitResult.UNLOCKED, msg
# predefine events for later use in assertions
event_sent_1 = {
"event": "EventPaymentSentSuccess",
"identifier": str(identifier1),
"target": to_checksum_address(app1.address),
"token_address": to_checksum_address(token_address0),
}
event_sent_2 = {
"event": "EventPaymentSentSuccess",
"identifier": str(identifier2),
"target": to_checksum_address(app2.address),
"token_address": to_checksum_address(token_address1),
}
event_sent_3 = {
"event": "EventPaymentSentSuccess",
"identifier": str(identifier3),
"target": to_checksum_address(app1.address),
"token_address": to_checksum_address(token_address0),
}
event_received_1 = {
"event": "EventPaymentReceivedSuccess",
"identifier": str(identifier1),
"initiator": to_checksum_address(app0.address),
"token_address": to_checksum_address(token_address0),
}
event_received_2 = {
"event": "EventPaymentReceivedSuccess",
"identifier": str(identifier2),
"initiator": to_checksum_address(app0.address),
"token_address": to_checksum_address(token_address1),
}
event_received_3 = {
"event": "EventPaymentReceivedSuccess",
"identifier": str(identifier3),
"initiator": to_checksum_address(app0.address),
"token_address": to_checksum_address(token_address0),
}
# test app0 endpoint without (partner and token) for sender
request = grequests.get(api_url_for(app0_server, "paymentresource"))
with watch_for_unlock_failures(*raiden_network):
response = request.send().response
assert_proper_response(response, HTTPStatus.OK)
json_response = get_json_response(response)
assert must_have_event(json_response, event_sent_1)
assert must_have_event(json_response, event_sent_2)
assert must_have_event(json_response, event_sent_3)
# test endpoint without (partner and token) for target1
request = grequests.get(api_url_for(app1_server, "paymentresource"))
response = request.send().response
assert_proper_response(response, HTTPStatus.OK)
json_response = get_json_response(response)
assert must_have_event(json_response, event_received_1)
assert must_have_event(json_response, event_received_3)
# test endpoint without (partner and token) for target2
request = grequests.get(api_url_for(app2_server, "paymentresource"))
response = request.send().response
assert_proper_response(response, HTTPStatus.OK)
json_response = get_json_response(response)
assert must_have_event(json_response, event_received_2)
# test endpoint without partner for app0
request = grequests.get(
api_url_for(app0_server,
"token_paymentresource",
token_address=token_address0))
response = request.send().response
assert_proper_response(response, HTTPStatus.OK)
json_response = get_json_response(response)
assert must_have_event(json_response, event_sent_1)
assert must_have_event(json_response, event_sent_3)
# test endpoint without partner for app0 but with limit/offset to get only first
request = grequests.get(
api_url_for(
app0_server,
"token_paymentresource",
token_address=token_address0,
limit=1,
offset=0,
))
response = request.send().response
assert_proper_response(response, HTTPStatus.OK)
json_response = get_json_response(response)
assert must_have_event(json_response, event_sent_1)
assert len(json_response) == 1
# test endpoint without partner for app0 but with limit/offset
# to get only second transfer of token_address
request = grequests.get(
api_url_for(
app0_server,
"token_paymentresource",
token_address=token_address0,
limit=1,
offset=1,
))
response = request.send().response
assert_proper_response(response, HTTPStatus.OK)
json_response = get_json_response(response)
# this should return only payment 3, since payment 1 is offset
# and payment 2 is of another token address
assert len(json_response) == 1
assert must_have_event(json_response, event_sent_3)
# test endpoint of app1 without partner for token_address
request = grequests.get(
api_url_for(app1_server,
"token_paymentresource",
token_address=token_address0))
response = request.send().response
assert_proper_response(response, HTTPStatus.OK)
json_response = get_json_response(response)
assert must_have_events(json_response, event_received_1)
assert must_have_events(json_response, event_received_3)
# test endpoint of app2 without partner for token_address
request = grequests.get(
api_url_for(app2_server,
"token_paymentresource",
token_address=token_address0))
response = request.send().response
assert_proper_response(response, HTTPStatus.OK)
json_response = get_json_response(response)
assert len(json_response) == 0
# test endpoint of app2 without partner for token_address2
request = grequests.get(
api_url_for(app2_server,
"token_paymentresource",
token_address=token_address1))
response = request.send().response
assert_proper_response(response, HTTPStatus.OK)
json_response = get_json_response(response)
assert must_have_events(json_response, event_received_2)
# test endpoint for token_address0 and partner for app0
request = grequests.get(
api_url_for(
app0_server,
"token_target_paymentresource",
token_address=token_address0,
target_address=app1.address,
))
response = request.send().response
assert_proper_response(response, HTTPStatus.OK)
json_response = get_json_response(response)
assert len(json_response) == 2
assert must_have_event(json_response, event_sent_1)
assert must_have_event(json_response, event_sent_3)
request = grequests.get(
api_url_for(
app0_server,
"token_target_paymentresource",
token_address=token_address1,
target_address=app2.address,
))
response = request.send().response
assert_proper_response(response, HTTPStatus.OK)
json_response = get_json_response(response)
assert len(json_response) == 1
assert must_have_event(json_response, event_sent_2)
# test endpoint for token_address0 and partner for app1. Check both partners
# to see that filtering works correctly
request = grequests.get(
api_url_for(
app1_server,
"token_target_paymentresource",
token_address=token_address0,
target_address=app2.address,
))
response = request.send().response
assert_proper_response(response, HTTPStatus.OK)
json_response = get_json_response(response)
assert len(json_response) == 0
request = grequests.get(
api_url_for(
app1_server,
"token_target_paymentresource",
token_address=token_address0,
target_address=app0.address,
))
response = request.send().response
assert_proper_response(response, HTTPStatus.OK)
json_response = get_json_response(response)
assert len(json_response) == 2
assert must_have_event(json_response, event_received_1)
assert must_have_event(json_response, event_received_3)
# test app1 checking payments to himself
request = grequests.get(
api_url_for(
app1_server,
"token_target_paymentresource",
token_address=token_address0,
target_address=app1.address,
))
response = request.send().response
assert_proper_response(response, HTTPStatus.OK)
json_response = get_json_response(response)
assert len(json_response) == 0
# test endpoint for token and partner for app2
request = grequests.get(
api_url_for(
app2_server,
"token_target_paymentresource",
token_address=token_address0,
target_address=app0.address,
))
response = request.send().response
assert_proper_response(response, HTTPStatus.OK)
json_response = get_json_response(response)
# Since app2 has no payment with app0 in token_address
assert len(json_response) == 0
# test endpoint for token2 and partner for app2
request = grequests.get(
api_url_for(
app2_server,
"token_target_paymentresource",
token_address=token_address1,
target_address=app0.address,
))
response = request.send().response
assert_proper_response(response, HTTPStatus.OK)
json_response = get_json_response(response)
# app2 has one payment with app0 in token_address2
assert len(json_response) == 1
assert must_have_events(json_response, event_received_2)
request = grequests.get(
api_url_for(
app2_server,
"token_target_paymentresource",
token_address=token_address0,
target_address=app1.address,
))
response = request.send().response
assert_proper_response(response, HTTPStatus.OK)
json_response = get_json_response(response)
assert not must_have_event(json_response, event_received_2)
# also add a test for filtering by wrong token address
request = grequests.get(
api_url_for(
app2_server,
"token_target_paymentresource",
token_address=app1.address,
target_address=app1.address,
))
response = request.send().response
assert_proper_response(response, HTTPStatus.BAD_REQUEST)
app1_server.stop()
app2_server.stop()
def test_pending_transfers_endpoint(raiden_network: List[RaidenService],
token_addresses):
initiator, mediator, target = raiden_network
token_address = token_addresses[0]
token_network_address = views.get_token_network_address_by_token_address(
views.state_from_raiden(mediator), mediator.default_registry.address,
token_address)
assert token_network_address
amount_to_send = PaymentAmount(150)
# Remove when https://github.com/raiden-network/raiden/issues/4982 is tackled
expected_fee = FeeAmount(
int(amount_to_send * INTERNAL_ROUTING_DEFAULT_FEE_PERC))
fee_margin = calculate_fee_margin(amount_to_send, expected_fee)
# This is 0,4% of ~150, so ~1.2 which gets rounded to 1
actual_fee = 1
identifier = PaymentID(42)
initiator_server = prepare_api_server(initiator)
mediator_server = prepare_api_server(mediator)
target_server = prepare_api_server(target)
target.message_handler = target_wait = WaitForMessage()
mediator.message_handler = mediator_wait = WaitForMessage()
secret = factories.make_secret()
secrethash = sha256_secrethash(secret)
request = grequests.get(
api_url_for(mediator_server,
"pending_transfers_resource_by_token",
token_address=token_address))
response = request.send().response
assert response.status_code == 200 and response.content == b"[]"
target_hold = target.raiden_event_handler
assert isinstance(
target_hold,
HoldRaidenEventHandler), "test app must use HoldRaidenEventHandler"
target_hold.hold_secretrequest_for(secrethash=secrethash)
initiator.mediated_transfer_async(
token_network_address=token_network_address,
amount=PaymentAmount(amount_to_send - expected_fee - fee_margin),
target=TargetAddress(target.address),
identifier=identifier,
secret=secret,
route_states=[
create_route_state_for_route(
apps=raiden_network,
token_address=token_address,
fee_estimate=expected_fee,
)
],
)
transfer_arrived = target_wait.wait_for_message(LockedTransfer,
{"payment_identifier": 42})
transfer_arrived.wait(timeout=30.0)
for server in (initiator_server, mediator_server, target_server):
request = grequests.get(
api_url_for(server, "pending_transfers_resource"))
response = request.send().response
assert response.status_code == 200
content = json.loads(response.content)
assert len(content) == 1
assert content[0]["payment_identifier"] == str(identifier)
if server == target_server:
assert content[0]["locked_amount"] == str(amount_to_send -
actual_fee)
else:
assert content[0]["locked_amount"] == str(amount_to_send)
assert content[0]["token_address"] == to_checksum_address(
token_address)
assert content[0]["token_network_address"] == to_checksum_address(
token_network_address)
mediator_unlock = mediator_wait.wait_for_message(Unlock, {})
target_unlock = target_wait.wait_for_message(Unlock, {})
target_hold.release_secretrequest_for(target, secrethash)
gevent.joinall({mediator_unlock, target_unlock}, raise_error=True)
for server in (initiator_server, mediator_server, target_server):
request = grequests.get(
api_url_for(server, "pending_transfers_resource"))
response = request.send().response
assert response.status_code == 200 and response.content == b"[]"
request = grequests.get(
api_url_for(
initiator_server,
"pending_transfers_resource_by_token",
token_address=to_hex(b"notaregisteredtokenn"),
))
response = request.send().response
assert response.status_code == 404 and b"Token" in response.content
request = grequests.get(
api_url_for(
target_server,
"pending_transfers_resource_by_token_and_partner",
token_address=token_address,
partner_address=to_hex(b"~nonexistingchannel~"),
))
response = request.send().response
assert response.status_code == 404 and b"Channel" in response.content
def test_payment_events_endpoints(api_server_test_instance: APIServer,
raiden_network, token_addresses):
app0, app1, app2 = raiden_network
amount1 = PaymentAmount(10)
identifier1 = PaymentID(42)
secret1, secrethash1 = factories.make_secret_with_hash()
token_address = token_addresses[0]
app0_address = app0.raiden.address
target1_address = app1.raiden.address
target2_address = app2.raiden.address
app1_server = prepare_api_server(app1)
app2_server = prepare_api_server(app2)
# app0 is sending tokens to target 1
request = grequests.post(
api_url_for(
api_server_test_instance,
"token_target_paymentresource",
token_address=to_checksum_address(token_address),
target_address=to_checksum_address(target1_address),
),
json={
"amount": str(amount1),
"identifier": str(identifier1),
"secret": to_hex(secret1)
},
)
request.send()
# app0 is sending some tokens to target 2
identifier2 = PaymentID(43)
amount2 = PaymentAmount(10)
secret2, secrethash2 = factories.make_secret_with_hash()
request = grequests.post(
api_url_for(
api_server_test_instance,
"token_target_paymentresource",
token_address=to_checksum_address(token_address),
target_address=to_checksum_address(target2_address),
),
json={
"amount": str(amount2),
"identifier": str(identifier2),
"secret": to_hex(secret2)
},
)
request.send()
# target1 also sends some tokens to target 2
identifier3 = PaymentID(44)
amount3 = PaymentAmount(5)
secret3, secrethash3 = factories.make_secret_with_hash()
request = grequests.post(
api_url_for(
app1_server,
"token_target_paymentresource",
token_address=to_checksum_address(token_address),
target_address=to_checksum_address(target2_address),
),
json={
"amount": str(amount3),
"identifier": str(identifier3),
"secret": to_hex(secret3)
},
)
request.send()
timeout = block_offset_timeout(
app2.raiden,
"Waiting for transfer received success in the WAL timed out")
with watch_for_unlock_failures(*raiden_network), timeout:
result = wait_for_received_transfer_result(
app1.raiden, identifier1, amount1, app1.raiden.alarm.sleep_time,
secrethash1)
msg = f"Unexpected transfer result: {str(result)}"
assert result == TransferWaitResult.UNLOCKED, msg
result = wait_for_received_transfer_result(
app2.raiden, identifier2, amount2, app2.raiden.alarm.sleep_time,
secrethash2)
msg = f"Unexpected transfer result: {str(result)}"
assert result == TransferWaitResult.UNLOCKED, msg
result = wait_for_received_transfer_result(
app2.raiden, identifier3, amount3, app2.raiden.alarm.sleep_time,
secrethash3)
msg = f"Unexpected transfer result: {str(result)}"
assert result == TransferWaitResult.UNLOCKED, msg
# test endpoint without (partner and token) for sender
request = grequests.get(
api_url_for(api_server_test_instance, "paymentresource"))
with watch_for_unlock_failures(*raiden_network):
response = request.send().response
assert_proper_response(response, HTTPStatus.OK)
json_response = get_json_response(response)
assert must_have_event(
json_response,
{
"event": "EventPaymentSentSuccess",
"identifier": str(identifier1),
"target": to_checksum_address(target1_address),
"token_address": to_checksum_address(token_address),
},
)
assert must_have_event(
json_response,
{
"event": "EventPaymentSentSuccess",
"identifier": str(identifier2),
"target": to_checksum_address(target2_address),
"token_address": to_checksum_address(token_address),
},
)
# test endpoint without (partner and token) for target1
request = grequests.get(api_url_for(app1_server, "paymentresource"))
response = request.send().response
assert_proper_response(response, HTTPStatus.OK)
json_response = get_json_response(response)
assert must_have_event(
json_response,
{
"event": "EventPaymentReceivedSuccess",
"identifier": str(identifier1),
"token_address": to_checksum_address(token_address),
},
)
assert must_have_event(
json_response,
{
"event": "EventPaymentSentSuccess",
"identifier": str(identifier3),
"token_address": to_checksum_address(token_address),
},
)
# test endpoint without (partner and token) for target2
request = grequests.get(api_url_for(app2_server, "paymentresource"))
response = request.send().response
assert_proper_response(response, HTTPStatus.OK)
json_response = get_json_response(response)
assert must_have_event(
json_response,
{
"event": "EventPaymentReceivedSuccess",
"identifier": str(identifier2),
"token_address": to_checksum_address(token_address),
},
)
assert must_have_event(
json_response,
{
"event": "EventPaymentReceivedSuccess",
"identifier": str(identifier3),
"token_address": to_checksum_address(token_address),
},
)
# test endpoint without partner for app0
request = grequests.get(
api_url_for(api_server_test_instance,
"token_paymentresource",
token_address=token_address))
response = request.send().response
assert_proper_response(response, HTTPStatus.OK)
json_response = get_json_response(response)
assert must_have_event(
json_response,
{
"event": "EventPaymentSentSuccess",
"identifier": str(identifier1),
"target": to_checksum_address(target1_address),
"token_address": to_checksum_address(token_address),
},
)
assert must_have_event(
json_response,
{
"event": "EventPaymentSentSuccess",
"identifier": str(identifier2),
"target": to_checksum_address(target2_address),
"token_address": to_checksum_address(token_address),
},
)
# test endpoint without partner for app0 but with limit/offset to get only first
request = grequests.get(
api_url_for(
api_server_test_instance,
"token_paymentresource",
token_address=token_address,
limit=1,
offset=0,
))
response = request.send().response
assert_proper_response(response, HTTPStatus.OK)
json_response = get_json_response(response)
assert must_have_event(
json_response,
{
"event": "EventPaymentSentSuccess",
"identifier": str(identifier1),
"target": to_checksum_address(target1_address),
"token_address": to_checksum_address(token_address),
},
)
assert len(json_response) == 1
# test endpoint without partner for app0 but with limit/offset to get only second
request = grequests.get(
api_url_for(
api_server_test_instance,
"token_paymentresource",
token_address=token_address,
limit=1,
offset=1,
))
response = request.send().response
assert_proper_response(response, HTTPStatus.OK)
json_response = get_json_response(response)
assert must_have_event(
json_response,
{
"event": "EventPaymentSentSuccess",
"identifier": str(identifier2),
"target": to_checksum_address(target2_address),
"token_address": to_checksum_address(token_address),
},
)
# test endpoint without partner for target1
request = grequests.get(
api_url_for(app1_server,
"token_paymentresource",
token_address=token_address))
response = request.send().response
assert_proper_response(response, HTTPStatus.OK)
json_response = get_json_response(response)
assert must_have_events(
json_response,
{
"event": "EventPaymentReceivedSuccess",
"identifier": str(identifier1),
"token_address": to_checksum_address(token_address),
},
{
"event": "EventPaymentSentSuccess",
"identifier": str(identifier3),
"target": to_checksum_address(target2_address),
"token_address": to_checksum_address(token_address),
},
)
# test endpoint without partner for target2
request = grequests.get(
api_url_for(app2_server,
"token_paymentresource",
token_address=token_address))
response = request.send().response
assert_proper_response(response, HTTPStatus.OK)
json_response = get_json_response(response)
assert must_have_events(
json_response,
{
"event": "EventPaymentReceivedSuccess",
"identifier": str(identifier2),
"token_address": to_checksum_address(token_address),
},
{
"event": "EventPaymentReceivedSuccess",
"identifier": str(identifier3),
"token_address": to_checksum_address(token_address),
},
)
# test endpoint for token and partner for app0
request = grequests.get(
api_url_for(
api_server_test_instance,
"token_target_paymentresource",
token_address=token_address,
target_address=target1_address,
))
response = request.send().response
assert_proper_response(response, HTTPStatus.OK)
json_response = get_json_response(response)
assert must_have_event(
json_response,
{
"event": "EventPaymentSentSuccess",
"identifier": str(identifier1),
"target": to_checksum_address(target1_address),
"token_address": to_checksum_address(token_address),
},
)
assert not must_have_event(
json_response,
{
"event": "EventPaymentSentSuccess",
"identifier": str(identifier2),
"target": to_checksum_address(target2_address),
"token_address": to_checksum_address(token_address),
},
)
# test endpoint for token and partner for target1. Check both partners
# to see that filtering works correctly
request = grequests.get(
api_url_for(
app1_server,
"token_target_paymentresource",
token_address=token_address,
target_address=target2_address,
))
response = request.send().response
assert_proper_response(response, HTTPStatus.OK)
json_response = get_json_response(response)
assert must_have_event(
json_response,
{
"event": "EventPaymentSentSuccess",
"identifier": str(identifier3),
"target": to_checksum_address(target2_address),
"token_address": to_checksum_address(token_address),
},
)
assert not must_have_event(
response,
{
"event": "EventPaymentReceivedSuccess",
"identifier": str(identifier1),
"token_address": to_checksum_address(token_address),
},
)
request = grequests.get(
api_url_for(
app1_server,
"token_target_paymentresource",
token_address=token_address,
target_address=target1_address,
))
response = request.send().response
assert_proper_response(response, HTTPStatus.OK)
json_response = get_json_response(response)
assert len(json_response) == 0
# test endpoint for token and partner for target2
request = grequests.get(
api_url_for(
app2_server,
"token_target_paymentresource",
token_address=token_address,
target_address=app0_address,
))
response = request.send().response
assert_proper_response(response, HTTPStatus.OK)
json_response = get_json_response(response)
assert must_have_events(
json_response,
{
"event": "EventPaymentReceivedSuccess",
"identifier": str(identifier2),
"token_address": to_checksum_address(token_address),
},
)
assert not must_have_event(
json_response,
{
"event": "EventPaymentReceivedSuccess",
"identifier": str(identifier1),
"token_address": to_checksum_address(token_address),
},
)
assert not must_have_event(
json_response,
{
"event": "EventPaymentReceivedSuccess",
"identifier": str(identifier3),
"token_address": to_checksum_address(token_address),
},
)
request = grequests.get(
api_url_for(
app2_server,
"token_target_paymentresource",
token_address=token_address,
target_address=target1_address,
))
response = request.send().response
assert_proper_response(response, HTTPStatus.OK)
json_response = get_json_response(response)
assert must_have_events(
json_response,
{
"event": "EventPaymentReceivedSuccess",
"identifier": str(identifier3),
"token_address": to_checksum_address(token_address),
},
)
assert not must_have_event(
json_response,
{
"event": "EventPaymentReceivedSuccess",
"identifier": str(identifier2),
"token_address": to_checksum_address(token_address),
},
)
assert not must_have_event(
json_response,
{
"event": "EventPaymentReceivedSuccess",
"identifier": str(identifier1),
"token_address": to_checksum_address(token_address),
},
)
# also add a test for filtering by wrong token address
request = grequests.get(
api_url_for(
app2_server,
"token_target_paymentresource",
token_address=target1_address,
target_address=target1_address,
))
response = request.send().response
assert_proper_response(response, HTTPStatus.OK)
json_response = get_json_response(response)
assert len(json_response) == 0
app1_server.stop()
app2_server.stop()
