def test_receive_payment_meets_travel_rule_threshold_sender_kyc_data_is_soft_match_and_accepted_receiver_kyc_data_is_soft_match_and_rejected(
currency: str,
travel_rule_threshold: int,
target_client: RestClient,
stub_client: RestClient,
) -> None:
"""
Test Plan:
1. Create sender account with kyc data that will be soft matched and then accepted by the target wallet application and enough balance in the stub wallet application.
2. Create receiver account with kyc data that will be soft matched and then rejected by the stub wallet application and 0 balance in the target wallet application.
3. Send payment from sender account to receiver account, amount is equal to travel_rule threshold.
4. Wait for stub wallet application account events include payment command states: ["S_INIT", "R_SOFT", "S_SOFT_SEND", "R_SEND", "S_SOFT", "R_SOFT_SEND", "S_ABORT"]
5. Expect sender and receiver accounts' balances are not changed.
"""
receive_payment_meets_travel_rule_threshold(
sender=stub_client.create_account(
balances={currency: travel_rule_threshold},
kyc_data=target_client.new_kyc_data(sample="soft_match"),
),
receiver=target_client.create_account(
kyc_data=stub_client.new_kyc_data(sample="soft_reject")),
payment_command_states=[
"S_INIT", "R_SOFT", "S_SOFT_SEND", "R_SEND", "S_SOFT",
"R_SOFT_SEND", "S_ABORT"
],
currency=currency,
amount=travel_rule_threshold,
)
def test_receive_payment_meets_travel_rule_threshold_receiver_kyc_data_is_soft_match_then_accepted_after_reviewing_additional_kyc_data(
currency: str,
travel_rule_threshold: int,
target_client: RestClient,
stub_client: RestClient,
) -> None:
"""
Test Plan:
1. Create sender account with minimum valid kyc data and enough balance in the stub wallet application.
2. Create receiver account with kyc data that will be soft matched by the stub wallet application and 0 balance in the target wallet application.
3. Send payment from sender account to receiver account, amount is equal to travel_rule threshold.
4. Wait for stub wallet application account events include payment command states: ["S_INIT", "R_SEND", "S_SOFT", "R_SOFT_SEND", "READY"]
5. Expect send payment success; receiver account balance increased by the amount sent; sender account balance decreased by the amount sent.
"""
receive_payment_meets_travel_rule_threshold(
sender=stub_client.create_account(
balances={currency: travel_rule_threshold},
kyc_data=target_client.new_kyc_data(sample="minimum"),
),
receiver=target_client.create_account(
kyc_data=stub_client.new_kyc_data(sample="soft_match")),
payment_command_states=[
"S_INIT", "R_SEND", "S_SOFT", "R_SOFT_SEND", "READY"
],
currency=currency,
amount=travel_rule_threshold,
)
def test_receive_payment_meets_travel_rule_threshold_sender_kyc_data_is_soft_match_then_receiver_aborts_for_sending_additional_kyc_data(
currency: str,
travel_rule_threshold: int,
target_client: RestClient,
stub_client: RestClient,
) -> None:
"""
Test Plan:
1. Create sender account with minimum valid kyc data and enough balance in the stub wallet application.
2. Create receiver account with kyc data that will be soft matched by the stub wallet application and 0 balance in the target wallet application.
3. Setup the stub wallet applicatoin to abort the payment command if receiver requests additional KYC data (soft match).
4. Send payment from sender account to receiver account, amount is equal to travel_rule threshold.
5. Wait for stub wallet application account events include payment command states: ["S_INIT", "R_SEND", "S_SOFT", "R_ABORT"]
6. Expect sender and receiver accounts' balances are not changed.
"""
receive_payment_meets_travel_rule_threshold(
sender=stub_client.create_account(
balances={currency: travel_rule_threshold},
kyc_data=target_client.new_kyc_data(sample="soft_match"),
reject_additional_kyc_data_request=True,
),
receiver=target_client.create_account(
kyc_data=stub_client.new_kyc_data(sample="minimum")),
payment_command_states=["S_INIT", "R_SOFT", "S_ABORT"],
currency=currency,
amount=travel_rule_threshold,
)
def test_send_payment_meets_travel_rule_threshold_sender_kyc_data_is_rejected_by_the_receiver(
currency: str,
travel_rule_threshold: int,
target_client: RestClient,
stub_client: RestClient,
) -> None:
"""
Test Plan:
1. Create sender account with kyc data that will be rejected by the stub wallet application in target wallet application.
2. Create receiver account with minimum valid kyc data and 0 balance in stub wallet application.
3. Send payment from sender account to receiver account, amount is equal to travel_rule threshold.
4. Wait for stub wallet application account events include payment command states: ["S_INIT", "R_ABORT"]
5 . Expect sender and receiver accounts' balances are not changed.
"""
send_payment_meets_travel_rule_threshold(
sender=target_client.create_account(
balances={currency: travel_rule_threshold},
kyc_data=stub_client.new_kyc_data(sample="reject")),
receiver=stub_client.create_account(
kyc_data=target_client.new_kyc_data(sample="minimum")),
payment_command_states=["S_INIT", "R_ABORT"],
currency=currency,
amount=travel_rule_threshold,
)
def test_send_payment_meets_travel_rule_threshold_both_kyc_data_evaluations_are_accepted(
currency: str,
travel_rule_threshold: int,
target_client: RestClient,
stub_client: RestClient,
) -> None:
"""
Test Plan:
1. Create sender account with minimum valid kyc data and enough balance in target wallet application.
2. Create receiver account with minimum valid kyc data with 0 balance in stub wallet application.
3. Send payment from sender account to receiver account, amount is equal to travel_rule threshold.
4. Wait for stub wallet application account events include payment command states: ["S_INIT", "R_SEND", "READY"]
5 . Expect send payment success; receiver account balance increased by the amount sent; sender account balance decreased by the amount sent.
"""
send_payment_meets_travel_rule_threshold(
sender=target_client.create_account(
balances={currency: travel_rule_threshold},
kyc_data=stub_client.new_kyc_data(sample="minimum")),
receiver=stub_client.create_account(
kyc_data=target_client.new_kyc_data(sample="minimum")),
payment_command_states=["S_INIT", "R_SEND", "READY"],
currency=currency,
amount=travel_rule_threshold,
)
def test_create_account_with_balances_and_kyc_data(target_client: RestClient,
currency: str) -> None:
kyc_data = target_client.new_kyc_data(sample="minimum")
balances = {currency: 123}
account = target_client.create_account(balances, kyc_data=kyc_data)
assert account.kyc_data == kyc_data
assert account.balances() == balances
def test_decoded_command_request_object_field_value_type_is_invalid(
stub_config: AppConfig,
stub_client: RestClient,
target_client: RestClient,
diem_client: jsonrpc.Client,
currency: str,
travel_rule_threshold: int,
hrp: str,
field_name: str,
) -> None:
"""
Test Plan:
1. Create a valid offchain request object.
2. Set a field value to boolean type True.
3. Send the request to the target wallet application offchain API endpoint.
4. Expect response status code is 400
5. Expect response `CommandResponseObject` with failure status, `protocol_error` error type,
and `invalid_field_value` error code.
"""
receiver_address = target_client.create_account(
).generate_account_identifier()
sender_address = stub_client.create_account().generate_account_identifier()
request = payment_command_request_sample(
sender_address=sender_address,
sender_kyc_data=target_client.new_kyc_data(sample="minimum"),
receiver_address=receiver_address,
currency=currency,
amount=travel_rule_threshold,
)
request[field_name] = True
status_code, resp = send_request_json(
diem_client,
stub_config.account,
sender_address,
receiver_address,
json.dumps(request),
hrp,
)
assert status_code == 400
assert resp.status == "failure"
assert_response_error(resp,
"invalid_field_value",
"protocol_error",
field=field_name)
def test_invalid_jws_message_signature(
stub_config: AppConfig,
target_client: RestClient,
diem_client: jsonrpc.Client,
currency: str,
travel_rule_threshold: int,
hrp: str,
) -> None:
"""
Test Plan:
1. Create a new on-chain account with base_url and a new compliance key.
2. Use new on-chain account address as sender address to create payment command request.
3. Send request to the target wallet application offchain API endpoint with new on-chain account address and a different compliance key.
4. Expect response status code is 400
5. Expect response `CommandResponseObject` with failure status, `protocol_error` error type,
and `invalid_jws_signature` error code.
"""
new_stub_account = testnet.gen_account(diem_client)
new_compliance_key = LocalAccount().compliance_public_key_bytes
new_stub_account.rotate_dual_attestation_info(diem_client,
stub_config.server_url,
new_compliance_key)
receiver_address = target_client.create_account(
).generate_account_identifier()
sender_address = new_stub_account.account_identifier()
request = payment_command_request_sample(
sender_address=sender_address,
sender_kyc_data=target_client.new_kyc_data(sample="minimum"),
receiver_address=receiver_address,
currency=currency,
amount=travel_rule_threshold,
)
status_code, resp = send_request_json(
diem_client,
new_stub_account,
sender_address,
receiver_address,
json.dumps(request),
hrp,
)
assert status_code == 400
assert resp.status == "failure"
assert_response_error(resp, "invalid_jws_signature", "protocol_error")
def test_invalid_jws_message_body_that_misses_parts(
stub_config: AppConfig,
target_client: RestClient,
stub_client: RestClient,
diem_client: jsonrpc.Client,
currency: str,
travel_rule_threshold: int,
hrp: str,
) -> None:
"""
Test Plan:
1. Create a new on-chain account with base_url and compliance key.
2. Use new on-chain account address as sender address to create payment command request.
3. Send request that missed jws header part to the target wallet application offchain API endpoint.
4. Expect response status code is 400
5. Expect response `CommandResponseObject` with failure status, `protocol_error` error type,
and `invalid_jws` error code.
"""
receiver_address = target_client.create_account(
).generate_account_identifier()
sender_address = stub_client.create_account().generate_account_identifier()
request = payment_command_request_sample(
sender_address=sender_address,
sender_kyc_data=target_client.new_kyc_data(sample="minimum"),
receiver_address=receiver_address,
currency=currency,
amount=travel_rule_threshold,
)
status_code, resp = send_request_json(
diem_client,
stub_config.account,
sender_address,
receiver_address,
json.dumps(request),
hrp,
request_body=b"invalid.jws_msg",
)
assert status_code == 400
assert resp.status == "failure"
assert_response_error(resp, "invalid_jws", "protocol_error")
def test_invalid_x_request_id(
stub_config: AppConfig,
target_client: RestClient,
stub_client: RestClient,
diem_client: jsonrpc.Client,
currency: str,
travel_rule_threshold: int,
hrp: str,
) -> None:
"""
Test Plan:
1. Create a valid offchain request object.
2. Send request to the target wallet application offchain API endpoint with X-Request-ID does not
match UUID format.
3. Expect response status code is 400
4. Expect response `CommandResponseObject` with failure status, `protocol_error` error type,
and `invalid_http_header` error code.
"""
receiver_address = target_client.create_account(
).generate_account_identifier()
sender_address = stub_client.create_account().generate_account_identifier()
request = payment_command_request_sample(
sender_address=sender_address,
sender_kyc_data=target_client.new_kyc_data(sample="minimum"),
receiver_address=receiver_address,
currency=currency,
amount=travel_rule_threshold,
)
status_code, resp = send_request_json(
diem_client,
stub_config.account,
sender_address,
receiver_address,
json.dumps(request),
hrp,
x_request_id="invalid uuid",
)
assert status_code == 400
assert resp.status == "failure"
assert_response_error(resp, "invalid_http_header", "protocol_error")
def test_account_balance_validation_should_exclude_canceled_transactions(
target_client: RestClient, stub_client: RestClient, currency: str,
travel_rule_threshold: int) -> None:
amount = travel_rule_threshold
receiver = target_client.create_account()
payee = receiver.generate_account_identifier()
sender = stub_client.create_account(
{currency: amount},
kyc_data=target_client.new_kyc_data(sample="reject"))
# payment should be rejected during offchain kyc data exchange
payment = sender.send_payment(currency, amount, payee=payee)
sender.wait_for_event("updated_transaction",
id=payment.id,
status="canceled")
sender.send_payment(currency, travel_rule_threshold - 1, payee)
receiver.wait_for_balance(currency, travel_rule_threshold - 1)
sender.wait_for_balance(currency, 1)
def test_x_request_sender_is_valid_but_no_compliance_key(
target_client: RestClient,
diem_client: jsonrpc.Client,
currency: str,
travel_rule_threshold: int,
hrp: str,
) -> None:
"""
Test Plan:
1. Create a new on-chain account without base_url and compliance key.
2. Use new on-chain account address as sender address to create payment command request.
3. Send request to the target wallet application offchain API endpoint with new on-chain account address.
4. Expect response status code is 400
5. Expect response `CommandResponseObject` with failure status, `protocol_error` error type,
and `invalid_http_header` error code.
"""
new_stub_account = testnet.gen_account(diem_client)
receiver_address = target_client.create_account(
).generate_account_identifier()
sender_address = new_stub_account.account_identifier()
request = payment_command_request_sample(
sender_address=sender_address,
sender_kyc_data=target_client.new_kyc_data(sample="minimum"),
receiver_address=receiver_address,
currency=currency,
amount=travel_rule_threshold,
)
status_code, resp = send_request_json(
diem_client,
new_stub_account,
sender_address,
receiver_address,
json.dumps(request),
hrp,
)
assert status_code == 400
assert resp.status == "failure"
assert_response_error(resp, "invalid_http_header", "protocol_error")
def assert_payment_command_field_error(
stub_config: AppConfig,
stub_client: RestClient,
target_client: RestClient,
diem_client: jsonrpc.Client,
currency: str,
travel_rule_threshold: int,
hrp: str,
field_name: str,
field_value: Union[None, str, int, List[int]],
error_code: str,
) -> None:
receiver_address = target_client.create_account(
).generate_account_identifier()
sender_address = stub_client.create_account().generate_account_identifier()
request = payment_command_request_sample(
sender_address=sender_address,
sender_kyc_data=target_client.new_kyc_data(sample="minimum"),
receiver_address=receiver_address,
currency=currency,
amount=travel_rule_threshold,
)
full_field_name = "command." + field_name
set_field(request, full_field_name, field_value)
status_code, resp = send_request_json(
diem_client,
stub_config.account,
sender_address,
receiver_address,
json.dumps(request),
hrp,
)
assert status_code == 400
assert resp.status == "failure"
assert_response_error(resp,
error_code,
"command_error",
field=full_field_name)