def test_register_token_without_balance( api_server_test_instance, token_amount, raiden_network: List[RaidenService], contract_manager, retry_timeout, ): app0 = raiden_network[0] contract_proxy, _ = app0.rpc_client.deploy_single_contract( contract_name=CONTRACT_HUMAN_STANDARD_TOKEN, contract=contract_manager.get_contract(CONTRACT_HUMAN_STANDARD_TOKEN), constructor_parameters=(token_amount, 2, "raiden", "Rd2"), ) new_token_address = Address(to_canonical_address(contract_proxy.address)) # Wait until Raiden can start using the token contract. # Here, the block at which the contract was deployed should be confirmed by Raiden. # Therefore, until that block is received. wait_for_block( raiden=app0, block_number=BlockNumber(app0.get_block_number() + DEFAULT_NUMBER_OF_BLOCK_CONFIRMATIONS + 1), retry_timeout=retry_timeout, ) # Burn all the eth and then make sure we get the appropriate API error burn_eth(app0.rpc_client) poor_request = grequests.put( api_url_for( api_server_test_instance, "registertokenresource", token_address=to_checksum_address(new_token_address), )) poor_response = poor_request.send().response assert_response_with_error(poor_response, HTTPStatus.PAYMENT_REQUIRED)
def test_api_testnet_token_mint(api_server_test_instance: APIServer, token_addresses): user_address = factories.make_checksum_address() token_address = token_addresses[0] url = api_url_for(api_server_test_instance, "tokensmintresource", token_address=token_address) request = grequests.post(url, json=dict(to=user_address, value=1)) response = request.send().response assert_response_with_code(response, HTTPStatus.OK) # mint method defaults to mintFor request = grequests.post(url, json=dict(to=user_address, value=10)) response = request.send().response assert_response_with_code(response, HTTPStatus.OK) # invalid due to negative value request = grequests.post(url, json=dict(to=user_address, value=-1)) response = request.send().response assert_response_with_error(response, HTTPStatus.BAD_REQUEST) # invalid due to invalid address request = grequests.post(url, json=dict(to=user_address[:-2], value=10)) response = request.send().response assert_response_with_error(response, HTTPStatus.BAD_REQUEST) # trying to mint with no ETH burn_eth(api_server_test_instance.rest_api.raiden_api.raiden.rpc_client) request = grequests.post(url, json=dict(to=user_address, value=1)) response = request.send().response assert_response_with_code(response, HTTPStatus.PAYMENT_REQUIRED)
def test_api_channel_set_reveal_timeout( api_server_test_instance: APIServer, raiden_network: List[RaidenService], token_addresses, settle_timeout, ): app0, app1 = raiden_network token_address = token_addresses[0] partner_address = app1.address request = grequests.patch( api_url_for( api_server_test_instance, "channelsresourcebytokenandpartneraddress", token_address=token_address, partner_address=partner_address, ), json=dict(reveal_timeout=0), ) response = request.send().response assert_response_with_error(response, HTTPStatus.CONFLICT) request = grequests.patch( api_url_for( api_server_test_instance, "channelsresourcebytokenandpartneraddress", token_address=token_address, partner_address=partner_address, ), json=dict(reveal_timeout=settle_timeout + 1), ) response = request.send().response assert_response_with_error(response, HTTPStatus.CONFLICT) reveal_timeout = int(settle_timeout / 2) request = grequests.patch( api_url_for( api_server_test_instance, "channelsresourcebytokenandpartneraddress", token_address=token_address, partner_address=partner_address, ), json=dict(reveal_timeout=reveal_timeout), ) response = request.send().response assert_response_with_code(response, HTTPStatus.OK) token_network_address = views.get_token_network_address_by_token_address( views.state_from_raiden(app0), app0.default_registry.address, token_address) assert token_network_address channel_state = views.get_channelstate_by_token_network_and_partner( chain_state=views.state_from_raiden(app0), token_network_address=token_network_address, partner_address=app1.address, ) assert channel_state assert channel_state.reveal_timeout == reveal_timeout
def test_payload_with_address_not_eip55(api_server_test_instance: APIServer): """ Provided addresses must be EIP55 encoded. """ invalid_address = "0xf696209d2ca35e6c88e5b99b7cda3abf316bed69" channel_data_obj = { "partner_address": invalid_address, "token_address": "0xEA674fdDe714fd979de3EdF0F56AA9716B898ec8", "settle_timeout": "90", } request = grequests.put(api_url_for(api_server_test_instance, "channelsresource"), json=channel_data_obj) response = request.send().response assert_response_with_error(response, HTTPStatus.BAD_REQUEST)
def test_payload_with_address_invalid_length( api_server_test_instance: APIServer): """ Encoded addresses must have the right length. """ invalid_address = "0x61c808d82a3ac53231750dadc13c777b59310b" # one char short channel_data_obj = { "partner_address": invalid_address, "token_address": "0xEA674fdDe714fd979de3EdF0F56AA9716B898ec8", "settle_timeout": "10", } request = grequests.put(api_url_for(api_server_test_instance, "channelsresource"), json=channel_data_obj) response = request.send().response assert_response_with_error(response, HTTPStatus.BAD_REQUEST)
def test_payload_with_address_invalid_chars( api_server_test_instance: APIServer): """ Addresses cannot have invalid characters in it. """ invalid_address = "0x61c808d82a3ac53231750dadc13c777b59310bdg" # g at the end is invalid channel_data_obj = { "partner_address": invalid_address, "token_address": "0xEA674fdDe714fd979de3EdF0F56AA9716B898ec8", "settle_timeout": "10", } request = grequests.put(api_url_for(api_server_test_instance, "channelsresource"), json=channel_data_obj) response = request.send().response assert_response_with_error(response, HTTPStatus.BAD_REQUEST)
def test_api_channel_open_channel_invalid_input( api_server_test_instance: APIServer, token_addresses, reveal_timeout): partner_address = "0x61C808D82A3Ac53231750daDc13c777b59310bD9" token_address = token_addresses[0] settle_timeout = TEST_SETTLE_TIMEOUT_MIN - 1 channel_data_obj = { "partner_address": partner_address, "token_address": to_checksum_address(token_address), "settle_timeout": str(settle_timeout), "reveal_timeout": str(reveal_timeout), } request = grequests.put(api_url_for(api_server_test_instance, "channelsresource"), json=channel_data_obj) response = request.send().response assert_response_with_error(response, status_code=HTTPStatus.CONFLICT) channel_data_obj["settle_timeout"] = str(TEST_SETTLE_TIMEOUT_MAX + 1) request = grequests.put(api_url_for(api_server_test_instance, "channelsresource"), json=channel_data_obj) response = request.send().response assert_response_with_error(response, status_code=HTTPStatus.CONFLICT) channel_data_obj["settle_timeout"] = str(TEST_SETTLE_TIMEOUT_MAX - 1) channel_data_obj["token_address"] = to_checksum_address( factories.make_address()) request = grequests.put(api_url_for(api_server_test_instance, "channelsresource"), json=channel_data_obj) response = request.send().response assert_response_with_error(response, status_code=HTTPStatus.CONFLICT)
def test_api_channel_withdraw(api_server_test_instance: APIServer, raiden_network: List[RaidenService], token_addresses): _, app1 = raiden_network token_address = token_addresses[0] partner_address = app1.address # Withdraw a 0 amount request = grequests.patch( api_url_for( api_server_test_instance, "channelsresourcebytokenandpartneraddress", token_address=token_address, partner_address=partner_address, ), json=dict(total_withdraw="0"), ) response = request.send().response assert_response_with_error(response, HTTPStatus.CONFLICT) # Withdraw an amount larger than balance request = grequests.patch( api_url_for( api_server_test_instance, "channelsresourcebytokenandpartneraddress", token_address=token_address, partner_address=partner_address, ), json=dict(total_withdraw="1500"), ) response = request.send().response assert_response_with_error(response, HTTPStatus.CONFLICT) # Withdraw a valid amount request = grequests.patch( api_url_for( api_server_test_instance, "channelsresourcebytokenandpartneraddress", token_address=token_address, partner_address=partner_address, ), json=dict(total_withdraw="750"), ) response = request.send().response assert_response_with_code(response, HTTPStatus.OK) # Withdraw same amount as before which would sum up to more than the balance request = grequests.patch( api_url_for( api_server_test_instance, "channelsresourcebytokenandpartneraddress", token_address=token_address, partner_address=partner_address, ), json=dict(total_withdraw="750"), ) response = request.send().response assert_response_with_error(response, HTTPStatus.CONFLICT)
def test_payload_with_invalid_addresses(api_server_test_instance: APIServer): """ Addresses require leading 0x in the payload. """ invalid_address = "61c808d82a3ac53231750dadc13c777b59310bd9" channel_data_obj = { "partner_address": invalid_address, "token_address": "0xEA674fdDe714fd979de3EdF0F56AA9716B898ec8", "settle_timeout": "10", } request = grequests.put(api_url_for(api_server_test_instance, "channelsresource"), json=channel_data_obj) response = request.send().response assert_response_with_error(response, HTTPStatus.BAD_REQUEST) url_without_prefix = ( "http://localhost:{port}/api/v1/channels/ea674fdde714fd979de3edf0f56aa9716b898ec8" ).format(port=api_server_test_instance.config.port) request = grequests.patch( url_without_prefix, json=dict(state=ChannelState.STATE_SETTLED.value)) response = request.send().response assert_response_with_code(response, HTTPStatus.NOT_FOUND)
def test_token_events_errors_for_unregistered_token(api_server_test_instance): request = grequests.get( api_url_for( api_server_test_instance, "tokenchanneleventsresourceblockchain", token_address="0x61C808D82A3Ac53231750daDc13c777b59310bD9", from_block="5", to_block="20", )) response = request.send().response assert_response_with_error(response, status_code=HTTPStatus.NOT_FOUND) request = grequests.get( api_url_for( api_server_test_instance, "channelblockchaineventsresource", token_address="0x61C808D82A3Ac53231750daDc13c777b59310bD9", partner_address="0x61C808D82A3Ac53231750daDc13c777b59313bD9", from_block="5", to_block="20", )) response = request.send().response assert_response_with_error(response, status_code=HTTPStatus.NOT_FOUND)
def test_api_payments_with_invalid_input(api_server_test_instance: APIServer, raiden_network, token_addresses): _, app1 = raiden_network amount = 100 token_address = token_addresses[0] target_address = app1.raiden.address settle_timeout = 39 # Invalid identifier being 0 or negative 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(target_address), ), json={ "amount": str(amount), "identifier": "0", "lock_timeout": str(settle_timeout) }, ) response = request.send().response assert_response_with_error(response, status_code=HTTPStatus.CONFLICT) 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(target_address), ), json={ "amount": str(amount), "identifier": "-1", "lock_timeout": str(settle_timeout) }, ) response = request.send().response assert_response_with_error(response, status_code=HTTPStatus.CONFLICT) 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(target_address), ), json={ "amount": str(amount), "identifier": str(UINT64_MAX + 1), "lock_timeout": str(settle_timeout), }, ) response = request.send().response assert_response_with_error(response, status_code=HTTPStatus.CONFLICT)
def test_api_payments_with_lock_timeout(api_server_test_instance: APIServer, raiden_network, token_addresses): _, app1 = raiden_network amount = 100 identifier = 42 token_address = token_addresses[0] target_address = app1.raiden.address number_of_nodes = 2 reveal_timeout = number_of_nodes * 4 + DEFAULT_NUMBER_OF_BLOCK_CONFIRMATIONS settle_timeout = 39 # try lock_timeout = reveal_timeout - should not work 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(target_address), ), json={ "amount": str(amount), "identifier": str(identifier), "lock_timeout": str(reveal_timeout), }, ) response = request.send().response assert_response_with_error(response, status_code=HTTPStatus.CONFLICT) # try lock_timeout = reveal_timeout * 2 - should work. 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(target_address), ), json={ "amount": str(amount), "identifier": str(identifier), "lock_timeout": str(2 * reveal_timeout), }, ) with watch_for_unlock_failures(*raiden_network): response = request.send().response assert_proper_response(response, status_code=HTTPStatus.OK) # try lock_timeout = settle_timeout - should work. 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(target_address), ), json={ "amount": str(amount), "identifier": str(identifier), "lock_timeout": str(settle_timeout), }, ) response = request.send().response assert_proper_response(response, status_code=HTTPStatus.OK) # try lock_timeout = settle_timeout+1 - should not work. 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(target_address), ), json={ "amount": amount, "identifier": identifier, "lock_timeout": settle_timeout + 1 }, ) response = request.send().response assert_response_with_error(response, status_code=HTTPStatus.CONFLICT)
def test_register_token( api_server_test_instance, token_amount, raiden_network: List[RaidenService], contract_manager, retry_timeout, ): app0 = raiden_network[0] contract_proxy, _ = app0.rpc_client.deploy_single_contract( contract_name=CONTRACT_HUMAN_STANDARD_TOKEN, contract=contract_manager.get_contract(CONTRACT_HUMAN_STANDARD_TOKEN), constructor_parameters=(token_amount, 2, "raiden", "Rd1"), ) new_token_address = Address(to_canonical_address(contract_proxy.address)) contract_proxy, _ = app0.rpc_client.deploy_single_contract( contract_name=CONTRACT_HUMAN_STANDARD_TOKEN, contract=contract_manager.get_contract(CONTRACT_HUMAN_STANDARD_TOKEN), constructor_parameters=(token_amount, 2, "raiden", "Rd2"), ) other_token_address = Address(to_canonical_address(contract_proxy.address)) # Wait until Raiden can start using the token contract. # Here, the block at which the contract was deployed should be confirmed by Raiden. # Therefore, until that block is received. wait_for_block( raiden=app0, block_number=BlockNumber(app0.get_block_number() + DEFAULT_NUMBER_OF_BLOCK_CONFIRMATIONS + 1), retry_timeout=retry_timeout, ) wait_for_block( raiden=app0, block_number=BlockNumber(app0.get_block_number() + DEFAULT_NUMBER_OF_BLOCK_CONFIRMATIONS + 1), retry_timeout=retry_timeout, ) register_request = grequests.put( api_url_for( api_server_test_instance, "registertokenresource", token_address=to_checksum_address(new_token_address), )) register_response = register_request.send().response assert_proper_response(register_response, status_code=HTTPStatus.CREATED) response_json = get_json_response(register_response) assert "token_network_address" in response_json assert is_checksum_address(response_json["token_network_address"]) # now try to reregister it and get the error conflict_request = grequests.put( api_url_for( api_server_test_instance, "registertokenresource", token_address=to_checksum_address(new_token_address), )) conflict_response = conflict_request.send().response assert_response_with_error(conflict_response, HTTPStatus.CONFLICT) # Test that adding a second token throws a forbidden error forbidden_request = grequests.put( api_url_for( api_server_test_instance, "registertokenresource", token_address=to_checksum_address(other_token_address), )) forbidden_response = forbidden_request.send().response assert_response_with_error(forbidden_response, HTTPStatus.FORBIDDEN) response_json = get_json_response(forbidden_response) assert "Number of token networks will exceed the maximum of" in response_json[ "errors"]
def test_api_channel_open_and_deposit(api_server_test_instance: APIServer, token_addresses, reveal_timeout): first_partner_address = "0x61C808D82A3Ac53231750daDc13c777b59310bD9" token_address = token_addresses[0] token_address_hex = to_checksum_address(token_address) settle_timeout = 1650 channel_data_obj = { "partner_address": first_partner_address, "token_address": token_address_hex, "settle_timeout": str(settle_timeout), "reveal_timeout": str(reveal_timeout), } # First let's try to create channel with the null address and see error is handled channel_data_obj["partner_address"] = NULL_ADDRESS_HEX request = grequests.put(api_url_for(api_server_test_instance, "channelsresource"), json=channel_data_obj) response = request.send().response assert_response_with_error(response, status_code=HTTPStatus.BAD_REQUEST) # now let's really create a new channel channel_data_obj["partner_address"] = first_partner_address request = grequests.put(api_url_for(api_server_test_instance, "channelsresource"), json=channel_data_obj) response = request.send().response assert_proper_response(response, HTTPStatus.CREATED) first_channel_id = 1 json_response = get_json_response(response) expected_response = channel_data_obj.copy() expected_response.update({ "balance": "0", "state": ChannelState.STATE_OPENED.value, "channel_identifier": "1", "total_deposit": "0", }) assert check_dict_nested_attrs(json_response, expected_response) token_network_address = json_response["token_network_address"] # Now let's try to open the same channel again, because it is possible for # the participants to race on the channel creation, this is not considered # an error. request = grequests.put(api_url_for(api_server_test_instance, "channelsresource"), json=channel_data_obj) response = request.send().response assert_proper_response(response, HTTPStatus.OK) json_response = get_json_response(response) assert check_dict_nested_attrs(json_response, expected_response) # now let's open a channel and make a deposit too second_partner_address = "0x29FA6cf0Cce24582a9B20DB94Be4B6E017896038" total_deposit = 100 channel_data_obj = { "partner_address": second_partner_address, "token_address": to_checksum_address(token_address), "settle_timeout": str(settle_timeout), "reveal_timeout": str(reveal_timeout), "total_deposit": str(total_deposit), } request = grequests.put(api_url_for(api_server_test_instance, "channelsresource"), json=channel_data_obj) response = request.send().response assert_proper_response(response, HTTPStatus.CREATED) second_channel_id = 2 json_response = get_json_response(response) expected_response = channel_data_obj.copy() expected_response.update({ "balance": str(total_deposit), "state": ChannelState.STATE_OPENED.value, "channel_identifier": str(second_channel_id), "token_network_address": token_network_address, "total_deposit": str(total_deposit), }) assert check_dict_nested_attrs(json_response, expected_response) # assert depositing again with less than the initial deposit returns 409 request = grequests.patch( api_url_for( api_server_test_instance, "channelsresourcebytokenandpartneraddress", token_address=token_address, partner_address=second_partner_address, ), json={"total_deposit": "99"}, ) response = request.send().response assert_proper_response(response, HTTPStatus.CONFLICT) # assert depositing negative amount fails request = grequests.patch( api_url_for( api_server_test_instance, "channelsresourcebytokenandpartneraddress", token_address=token_address, partner_address=first_partner_address, ), json={"total_deposit": "-1000"}, ) response = request.send().response assert_proper_response(response, HTTPStatus.CONFLICT) # let's deposit on the first channel request = grequests.patch( api_url_for( api_server_test_instance, "channelsresourcebytokenandpartneraddress", token_address=token_address, partner_address=first_partner_address, ), json={"total_deposit": str(total_deposit)}, ) response = request.send().response assert_proper_response(response) json_response = get_json_response(response) expected_response = { "channel_identifier": str(first_channel_id), "partner_address": first_partner_address, "token_address": to_checksum_address(token_address), "settle_timeout": str(settle_timeout), "reveal_timeout": str(reveal_timeout), "state": ChannelState.STATE_OPENED.value, "balance": str(total_deposit), "total_deposit": str(total_deposit), "token_network_address": token_network_address, } assert check_dict_nested_attrs(json_response, expected_response) # let's try querying for the second channel request = grequests.get( api_url_for( api_server_test_instance, "channelsresourcebytokenandpartneraddress", token_address=token_address, partner_address=second_partner_address, )) response = request.send().response assert_proper_response(response) json_response = get_json_response(response) expected_response = { "channel_identifier": str(second_channel_id), "partner_address": second_partner_address, "token_address": to_checksum_address(token_address), "settle_timeout": str(settle_timeout), "reveal_timeout": str(reveal_timeout), "state": ChannelState.STATE_OPENED.value, "balance": str(total_deposit), "total_deposit": str(total_deposit), "token_network_address": token_network_address, } assert check_dict_nested_attrs(json_response, expected_response) # finally let's burn all eth and try to open another channel burn_eth(api_server_test_instance.rest_api.raiden_api.raiden.rpc_client) channel_data_obj = { "partner_address": "0xf3AF96F89b3d7CdcBE0C083690A28185Feb0b3CE", "token_address": to_checksum_address(token_address), "settle_timeout": str(settle_timeout), "reveal_timeout": str(reveal_timeout), } request = grequests.put(api_url_for(api_server_test_instance, "channelsresource"), json=channel_data_obj) response = request.send().response assert_proper_response(response, HTTPStatus.PAYMENT_REQUIRED) json_response = get_json_response(response) assert "The account balance is below the estimated amount" in json_response[ "errors"]
def test_api_channel_state_change_errors(api_server_test_instance: APIServer, token_addresses, reveal_timeout): partner_address = "0x61C808D82A3Ac53231750daDc13c777b59310bD9" token_address = token_addresses[0] settle_timeout = 1650 channel_data_obj = { "partner_address": partner_address, "token_address": to_checksum_address(token_address), "settle_timeout": str(settle_timeout), "reveal_timeout": str(reveal_timeout), } request = grequests.put(api_url_for(api_server_test_instance, "channelsresource"), json=channel_data_obj) response = request.send().response assert_proper_response(response, HTTPStatus.CREATED) # let's try to set a random state request = grequests.patch( api_url_for( api_server_test_instance, "channelsresourcebytokenandpartneraddress", token_address=token_address, partner_address=partner_address, ), json=dict(state="inlimbo"), ) response = request.send().response assert_response_with_error(response, HTTPStatus.BAD_REQUEST) # let's try to set both new state and total_deposit request = grequests.patch( api_url_for( api_server_test_instance, "channelsresourcebytokenandpartneraddress", token_address=token_address, partner_address=partner_address, ), json=dict(state=ChannelState.STATE_CLOSED.value, total_deposit="200"), ) response = request.send().response assert_response_with_error(response, HTTPStatus.CONFLICT) # let's try to set both new state and total_withdraw request = grequests.patch( api_url_for( api_server_test_instance, "channelsresourcebytokenandpartneraddress", token_address=token_address, partner_address=partner_address, ), json=dict(state=ChannelState.STATE_CLOSED.value, total_withdraw="200"), ) response = request.send().response assert_response_with_error(response, HTTPStatus.CONFLICT) # let's try to set both total deposit and total_withdraw request = grequests.patch( api_url_for( api_server_test_instance, "channelsresourcebytokenandpartneraddress", token_address=token_address, partner_address=partner_address, ), json=dict(total_deposit="500", total_withdraw="200"), ) response = request.send().response assert_response_with_error(response, HTTPStatus.CONFLICT) # let's try to set both new state and reveal_timeout request = grequests.patch( api_url_for( api_server_test_instance, "channelsresourcebytokenandpartneraddress", token_address=token_address, partner_address=partner_address, ), json=dict(state=ChannelState.STATE_CLOSED.value, reveal_timeout="50"), ) response = request.send().response assert_response_with_error(response, HTTPStatus.CONFLICT) # let's try to set both total_deposit and reveal_timeout request = grequests.patch( api_url_for( api_server_test_instance, "channelsresourcebytokenandpartneraddress", token_address=token_address, partner_address=partner_address, ), json=dict(total_deposit="500", reveal_timeout="50"), ) response = request.send().response assert_response_with_error(response, HTTPStatus.CONFLICT) # let's try to set both total_withdraw and reveal_timeout request = grequests.patch( api_url_for( api_server_test_instance, "channelsresourcebytokenandpartneraddress", token_address=token_address, partner_address=partner_address, ), json=dict(total_withdraw="500", reveal_timeout="50"), ) response = request.send().response assert_response_with_error(response, HTTPStatus.CONFLICT) # let's try to patch with no arguments request = grequests.patch( api_url_for( api_server_test_instance, "channelsresourcebytokenandpartneraddress", token_address=token_address, partner_address=partner_address, )) response = request.send().response assert_response_with_error(response, HTTPStatus.BAD_REQUEST) # ok now let's close and settle for real request = grequests.patch( api_url_for( api_server_test_instance, "channelsresourcebytokenandpartneraddress", token_address=token_address, partner_address=partner_address, ), json=dict(state=ChannelState.STATE_CLOSED.value), ) response = request.send().response assert_proper_response(response) # let's try to deposit to a settled channel request = grequests.patch( api_url_for( api_server_test_instance, "channelsresourcebytokenandpartneraddress", token_address=token_address, partner_address=partner_address, ), json=dict(total_deposit="500"), ) response = request.send().response assert_response_with_error(response, HTTPStatus.CONFLICT)