def deploy_smoketest_contracts(client, chain_id):
client.web3.personal.unlockAccount(
client.web3.eth.accounts[0],
TEST_ACCOUNT_PASSWORD,
)
endpoint_registry_address = deploy_contract_web3(
CONTRACT_ENDPOINT_REGISTRY,
client,
)
secret_registry_address = deploy_contract_web3(
CONTRACT_SECRET_REGISTRY,
client,
)
gevent.sleep(1) # FIXME: properly wait for block
token_network_registry_address = deploy_contract_web3(
CONTRACT_TOKEN_NETWORK_REGISTRY,
client,
to_checksum_address(secret_registry_address),
chain_id,
TEST_SETTLE_TIMEOUT_MIN,
TEST_SETTLE_TIMEOUT_MAX,
)
addresses = {
CONTRACT_ENDPOINT_REGISTRY: endpoint_registry_address,
CONTRACT_SECRET_REGISTRY: secret_registry_address,
CONTRACT_TOKEN_NETWORK_REGISTRY: token_network_registry_address,
}
return addresses
def test_register_token(api_backend, token_amount, token_addresses,
raiden_network):
app0 = raiden_network[0]
new_token_address = deploy_contract_web3(
CONTRACT_HUMAN_STANDARD_TOKEN,
app0.raiden.chain.client,
num_confirmations=None,
constructor_arguments=(
token_amount,
2,
'raiden',
'Rd',
),
)
other_token_address = deploy_contract_web3(
CONTRACT_HUMAN_STANDARD_TOKEN,
app0.raiden.chain.client,
num_confirmations=None,
constructor_arguments=(
token_amount,
2,
'raiden',
'Rd',
),
)
register_request = grequests.put(
api_url_for(
api_backend,
'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 = register_response.json()
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_backend,
'registertokenresource',
token_address=to_checksum_address(new_token_address),
))
conflict_response = conflict_request.send().response
assert_response_with_error(conflict_response, HTTPStatus.CONFLICT)
# Burn all the eth and then make sure we get the appropriate API error
burn_all_eth(app0.raiden)
poor_request = grequests.put(
api_url_for(
api_backend,
'registertokenresource',
token_address=to_checksum_address(other_token_address),
))
poor_response = poor_request.send().response
assert_response_with_error(poor_response, HTTPStatus.PAYMENT_REQUIRED)
def deploy_smoketest_contracts(
client: JSONRPCClient,
chain_id: ChainID,
contract_manager: ContractManager,
token_address: AddressHex,
) -> Dict[str, Address]:
client.web3.personal.unlockAccount(client.web3.eth.accounts[0],
DEFAULT_PASSPHRASE)
secret_registry_address = deploy_contract_web3(
contract_name=CONTRACT_SECRET_REGISTRY,
deploy_client=client,
contract_manager=contract_manager,
)
constructor_arguments = [
to_checksum_address(secret_registry_address),
chain_id,
TEST_SETTLE_TIMEOUT_MIN,
TEST_SETTLE_TIMEOUT_MAX,
UINT256_MAX,
]
token_network_registry_address = deploy_contract_web3(
contract_name=CONTRACT_TOKEN_NETWORK_REGISTRY,
deploy_client=client,
contract_manager=contract_manager,
constructor_arguments=constructor_arguments,
)
addresses = {
CONTRACT_SECRET_REGISTRY: secret_registry_address,
CONTRACT_TOKEN_NETWORK_REGISTRY: token_network_registry_address,
}
service_registry_address = deploy_contract_web3(
contract_name=CONTRACT_SERVICE_REGISTRY,
deploy_client=client,
contract_manager=contract_manager,
constructor_arguments=(
token_address,
EMPTY_ADDRESS,
int(500e18),
6,
5,
180 * SECONDS_PER_DAY,
1000,
200 * SECONDS_PER_DAY,
),
)
addresses[CONTRACT_SERVICE_REGISTRY] = service_registry_address
# The MSC is not used, no need to waste time on deployment
addresses[CONTRACT_MONITORING_SERVICE] = make_address()
# The OneToN contract is not used, no need to waste time on deployment
addresses[CONTRACT_ONE_TO_N] = make_address()
return addresses
def test_register_token(api_backend, token_amount, token_addresses, raiden_network):
app0 = raiden_network[0]
new_token_address = deploy_contract_web3(
CONTRACT_HUMAN_STANDARD_TOKEN,
app0.raiden.chain.client,
num_confirmations=None,
constructor_arguments=(
token_amount,
2,
'raiden',
'Rd',
),
)
other_token_address = deploy_contract_web3(
CONTRACT_HUMAN_STANDARD_TOKEN,
app0.raiden.chain.client,
num_confirmations=None,
constructor_arguments=(
token_amount,
2,
'raiden',
'Rd',
),
)
register_request = grequests.put(api_url_for(
api_backend,
'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 = register_response.json()
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_backend,
'registertokenresource',
token_address=to_checksum_address(new_token_address),
))
conflict_response = conflict_request.send().response
assert_response_with_error(conflict_response, HTTPStatus.CONFLICT)
# Burn all the eth and then make sure we get the appropriate API error
burn_all_eth(app0.raiden)
poor_request = grequests.put(api_url_for(
api_backend,
'registertokenresource',
token_address=to_checksum_address(other_token_address),
))
poor_response = poor_request.send().response
assert_response_with_error(poor_response, HTTPStatus.PAYMENT_REQUIRED)
def deploy_smoketest_contracts(
client: JSONRPCClient,
chain_id: ChainID,
contract_manager: ContractManager,
token_address: AddressHex,
) -> Dict[str, Address]:
client.web3.personal.unlockAccount(
client.web3.eth.accounts[0],
DEFAULT_PASSPHRASE,
)
endpoint_registry_address = deploy_contract_web3(
contract_name=CONTRACT_ENDPOINT_REGISTRY,
deploy_client=client,
contract_manager=contract_manager,
)
secret_registry_address = deploy_contract_web3(
contract_name=CONTRACT_SECRET_REGISTRY,
deploy_client=client,
contract_manager=contract_manager,
)
constructor_arguments = [
to_checksum_address(secret_registry_address),
chain_id,
TEST_SETTLE_TIMEOUT_MIN,
TEST_SETTLE_TIMEOUT_MAX,
]
if contract_manager.contracts_version == DEVELOPMENT_CONTRACT_VERSION:
constructor_arguments.append(UINT256_MAX)
token_network_registry_address = deploy_contract_web3(
contract_name=CONTRACT_TOKEN_NETWORK_REGISTRY,
deploy_client=client,
contract_manager=contract_manager,
constructor_arguments=constructor_arguments,
)
addresses = {
CONTRACT_ENDPOINT_REGISTRY: endpoint_registry_address,
CONTRACT_SECRET_REGISTRY: secret_registry_address,
CONTRACT_TOKEN_NETWORK_REGISTRY: token_network_registry_address,
}
if contract_manager.contracts_version == DEVELOPMENT_CONTRACT_VERSION:
service_registry_address = deploy_contract_web3(
contract_name=CONTRACT_SERVICE_REGISTRY,
deploy_client=client,
contract_manager=contract_manager,
constructor_arguments=(token_address, ),
)
addresses[CONTRACT_SERVICE_REGISTRY] = service_registry_address
return addresses
def test_register_token_insufficient_eth(raiden_network, token_amount,
contract_manager):
app1 = raiden_network[0]
registry_address = app1.raiden.default_registry.address
token_address = deploy_contract_web3(
contract_name=CONTRACT_HUMAN_STANDARD_TOKEN,
deploy_client=app1.raiden.chain.client,
contract_manager=contract_manager,
constructor_arguments=(
token_amount,
2,
'raiden',
'Rd',
),
)
api1 = RaidenAPI(app1.raiden)
assert token_address not in api1.get_tokens_list(registry_address)
# app1.raiden loses all its ETH because it has been naughty
burn_eth(app1.raiden)
# At this point we should get an UnrecoverableError due to InsufficientFunds
with pytest.raises(InsufficientFunds):
api1.token_network_register(registry_address, token_address)
def deploy_token_network_registry_and_return_address(
deploy_client: JSONRPCClient,
secret_registry_address: SecretRegistryAddress,
chain_id: ChainID,
settle_timeout_min: int,
settle_timeout_max: int,
max_token_networks: int,
contract_manager: ContractManager,
) -> TokenNetworkRegistryAddress:
constructor_arguments = [
to_checksum_address(secret_registry_address),
chain_id,
settle_timeout_min,
settle_timeout_max,
max_token_networks,
]
address = deploy_contract_web3(
contract_name=CONTRACT_TOKEN_NETWORK_REGISTRY,
deploy_client=deploy_client,
contract_manager=contract_manager,
constructor_arguments=constructor_arguments,
)
return TokenNetworkRegistryAddress(to_canonical_address(address))
def secret_registry_address(deploy_client, contract_manager) -> typing.Address:
address = deploy_contract_web3(
contract_name=CONTRACT_SECRET_REGISTRY,
deploy_client=deploy_client,
contract_manager=contract_manager,
)
return address
def deploy_user_deposit_and_return_address(
proxy_manager: ProxyManager,
deploy_client: JSONRPCClient,
contract_manager: ContractManager,
token_proxy: Token,
private_keys: List[PrivateKey],
environment_type: Environment,
) -> Optional[Address]:
""" Deploy UserDeposit and fund accounts with some balances """
if environment_type != Environment.DEVELOPMENT:
return None
constructor_arguments = [token_proxy.address, UINT256_MAX]
user_deposit_address = deploy_contract_web3(
contract_name=CONTRACT_USER_DEPOSIT,
deploy_client=deploy_client,
contract_manager=contract_manager,
constructor_arguments=constructor_arguments,
)
user_deposit = proxy_manager.user_deposit(
UserDepositAddress(user_deposit_address))
participants = [privatekey_to_address(key) for key in private_keys]
for transfer_to in participants:
user_deposit.deposit(
beneficiary=transfer_to,
total_deposit=MONITORING_REWARD,
given_block_identifier="latest",
)
return user_deposit_address
def test_endpointregistry(private_keys, blockchain_services, contract_manager):
chain = blockchain_services.blockchain_services[0]
my_address = privatekey_to_address(private_keys[0])
endpointregistry_address = deploy_contract_web3(
contract_name=CONTRACT_ENDPOINT_REGISTRY,
deploy_client=chain.client,
contract_manager=contract_manager,
)
discovery_proxy = chain.discovery(endpointregistry_address)
contract_discovery = ContractDiscovery(my_address, discovery_proxy)
unregistered_address = make_address()
# get should raise for unregistered addresses
with pytest.raises(UnknownAddress):
contract_discovery.get(my_address)
with pytest.raises(UnknownAddress):
contract_discovery.get(unregistered_address)
contract_discovery.register(my_address, '127.0.0.1', 44444)
assert contract_discovery.get(my_address) == ('127.0.0.1', 44444)
contract_discovery.register(my_address, '127.0.0.1', 88888)
assert contract_discovery.get(my_address) == ('127.0.0.1', 88888)
with pytest.raises(UnknownAddress):
contract_discovery.get(unregistered_address)
def endpoint_registry_address(deploy_client, contract_manager) -> typing.Address:
address = deploy_contract_web3(
contract_name=CONTRACT_ENDPOINT_REGISTRY,
deploy_client=deploy_client,
contract_manager=contract_manager,
)
return address
def secret_registry_address(deploy_client) -> typing.Address:
address = deploy_contract_web3(
CONTRACT_SECRET_REGISTRY,
deploy_client,
num_confirmations=None,
)
return address
def maybe_deploy_service_registry_and_return_address(
deploy_client: JSONRPCClient,
contract_manager: ContractManager,
token_proxy: Token,
environment_type: Environment,
) -> Optional[Address]:
if environment_type == Environment.PRODUCTION:
return None
# Not sure what to put in the registration fee token for testing, so using
# the same token we use for testing for now
constructor_arguments = (
token_proxy.address,
EMPTY_ADDRESS,
int(500e18),
6,
5,
180 * SECONDS_PER_DAY,
1000,
200 * SECONDS_PER_DAY,
)
address = deploy_contract_web3(
contract_name=CONTRACT_SERVICE_REGISTRY,
deploy_client=deploy_client,
contract_manager=contract_manager,
constructor_arguments=constructor_arguments,
)
return address
def test_register_token_insufficient_eth(raiden_network, token_amount, contract_manager):
app1 = raiden_network[0]
registry_address = app1.raiden.default_registry.address
token_address = deploy_contract_web3(
contract_name=CONTRACT_HUMAN_STANDARD_TOKEN,
deploy_client=app1.raiden.chain.client,
contract_manager=contract_manager,
constructor_arguments=(
token_amount,
2,
'raiden',
'Rd',
),
)
api1 = RaidenAPI(app1.raiden)
assert token_address not in api1.get_tokens_list(registry_address)
# app1.raiden loses all its ETH because it has been naughty
burn_eth(app1.raiden)
# At this point we should get an UnrecoverableError due to InsufficientFunds
with pytest.raises(InsufficientFunds):
api1.token_network_register(registry_address, token_address)
def deploy_token_network_registry_and_return_address(
deploy_client,
secret_registry_address,
chain_id,
settle_timeout_min,
settle_timeout_max,
contract_manager,
environment_type,
) -> typing.Address:
constructor_arguments = [
to_checksum_address(secret_registry_address),
chain_id,
settle_timeout_min,
settle_timeout_max,
]
if environment_type == Environment.DEVELOPMENT:
constructor_arguments.append(UINT256_MAX)
address = deploy_contract_web3(
contract_name=CONTRACT_TOKEN_NETWORK_REGISTRY,
deploy_client=deploy_client,
contract_manager=contract_manager,
constructor_arguments=constructor_arguments,
)
return address
def endpoint_registry_address(deploy_client) -> typing.Address:
address = deploy_contract_web3(
CONTRACT_ENDPOINT_REGISTRY,
deploy_client,
num_confirmations=None,
)
return address
def test_register_token(raiden_network, token_amount):
app1 = raiden_network[0]
registry_address = app1.raiden.default_registry.address
token_address = deploy_contract_web3(
CONTRACT_HUMAN_STANDARD_TOKEN,
app1.raiden.chain.client,
num_confirmations=None,
constructor_arguments=(
token_amount,
2,
'raiden',
'Rd',
),
)
api1 = RaidenAPI(app1.raiden)
assert token_address not in api1.get_tokens_list(registry_address)
api1.token_network_register(registry_address, token_address)
assert token_address in api1.get_tokens_list(registry_address)
# Exception if we try to reregister
with pytest.raises(AlreadyRegisteredTokenAddress):
api1.token_network_register(registry_address, token_address)
def run_test_token_registered_race(raiden_chain, token_amount, retry_timeout, contract_manager):
app0, app1 = raiden_chain
api0 = RaidenAPI(app0.raiden)
api1 = RaidenAPI(app1.raiden)
# Recreate the race condition by making sure the non-registering app won't
# register at all by watching for the TokenAdded blockchain event.
event_listeners = app1.raiden.blockchain_events.event_listeners
app1.raiden.blockchain_events.event_listeners = list()
token_address = deploy_contract_web3(
contract_name=CONTRACT_HUMAN_STANDARD_TOKEN,
deploy_client=app1.raiden.chain.client,
contract_manager=contract_manager,
constructor_arguments=(
token_amount,
2,
'raiden',
'Rd',
),
)
gevent.sleep(1)
registry_address = app0.raiden.default_registry.address
assert token_address not in api0.get_tokens_list(registry_address)
assert token_address not in api1.get_tokens_list(registry_address)
api0.token_network_register(
registry_address=registry_address,
token_address=token_address,
channel_participant_deposit_limit=UINT256_MAX,
token_network_deposit_limit=UINT256_MAX,
)
exception = RuntimeError('Did not see the token registration within 30 seconds')
with gevent.Timeout(seconds=30, exception=exception):
wait_for_state_change(
app0.raiden,
ContractReceiveNewTokenNetwork,
{
'token_network': {
'token_address': token_address,
},
},
retry_timeout,
)
assert token_address in api0.get_tokens_list(registry_address)
assert token_address not in api1.get_tokens_list(registry_address)
# The next time when the event is polled, the token is registered
app1.raiden.blockchain_events.event_listeners = event_listeners
waiting.wait_for_block(
app1.raiden,
app1.raiden.get_block_number() + 1,
retry_timeout,
)
assert token_address in api1.get_tokens_list(registry_address)
def secret_registry_address(deploy_client) -> typing.Address:
address = deploy_contract_web3(
CONTRACT_SECRET_REGISTRY,
deploy_client,
num_confirmations=None,
)
return address
def test_register_token_insufficient_eth(raiden_network, token_amount):
app1 = raiden_network[0]
registry_address = app1.raiden.default_registry.address
token_address = deploy_contract_web3(
CONTRACT_HUMAN_STANDARD_TOKEN,
app1.raiden.chain.client,
num_confirmations=None,
constructor_arguments=(
token_amount,
2,
'raiden',
'Rd',
),
)
api1 = RaidenAPI(app1.raiden)
assert token_address not in api1.get_tokens_list(registry_address)
# app1.raiden loses all its ETH because it has been naughty
burn_all_eth(app1.raiden)
# At this point we should get the InsufficientFunds exception
with pytest.raises(InsufficientFunds):
api1.token_network_register(registry_address, token_address)
def secret_registry_address(deploy_client, contract_manager) -> typing.Address:
address = deploy_contract_web3(
contract_name=CONTRACT_SECRET_REGISTRY,
deploy_client=deploy_client,
contract_manager=contract_manager,
)
return address
def endpoint_registry_address(deploy_client) -> typing.Address:
address = deploy_contract_web3(
CONTRACT_ENDPOINT_REGISTRY,
deploy_client,
num_confirmations=None,
)
return address
def test_endpointregistry(private_keys, blockchain_services, contract_manager):
chain = blockchain_services.blockchain_services[0]
my_address = privatekey_to_address(private_keys[0])
endpointregistry_address = deploy_contract_web3(
contract_name=CONTRACT_ENDPOINT_REGISTRY,
deploy_client=chain.client,
contract_manager=contract_manager,
num_confirmations=None,
)
discovery_proxy = chain.discovery(endpointregistry_address)
contract_discovery = ContractDiscovery(my_address, discovery_proxy)
unregistered_address = make_address()
# get should raise for unregistered addresses
with pytest.raises(UnknownAddress):
contract_discovery.get(my_address)
with pytest.raises(UnknownAddress):
contract_discovery.get(unregistered_address)
contract_discovery.register(my_address, '127.0.0.1', 44444)
assert contract_discovery.get(my_address) == ('127.0.0.1', 44444)
contract_discovery.register(my_address, '127.0.0.1', 88888)
assert contract_discovery.get(my_address) == ('127.0.0.1', 88888)
with pytest.raises(UnknownAddress):
contract_discovery.get(unregistered_address)
def deploy_user_deposit_and_return_address(
deploy_service,
deploy_client,
contract_manager,
token_proxy,
private_keys,
environment_type,
) -> typing.Optional[typing.Address]:
""" Deploy a token to emulate RDN and fund accounts with some balances."""
if environment_type != Environment.DEVELOPMENT:
return None
constructor_arguments = [
token_proxy.address,
UINT256_MAX,
]
user_deposit_address = deploy_contract_web3(
contract_name=CONTRACT_USER_DEPOSIT,
deploy_client=deploy_client,
contract_manager=contract_manager,
constructor_arguments=constructor_arguments,
)
user_deposit = deploy_service.user_deposit(user_deposit_address)
participants = [privatekey_to_address(key) for key in private_keys]
for transfer_to in participants:
user_deposit.deposit(
beneficiary=transfer_to,
total_deposit=100,
block_identifier='latest',
)
return user_deposit_address
def test_register_token(api_backend, token_amount, token_addresses,
raiden_network):
app0 = raiden_network[0]
new_token_address = deploy_contract_web3(
CONTRACT_HUMAN_STANDARD_TOKEN,
app0.raiden.chain.client,
token_amount,
2,
'raiden',
'Rd',
)
register_request = grequests.put(
api_url_for(
api_backend,
'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 = register_response.json()
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_backend,
'registertokenresource',
token_address=to_checksum_address(new_token_address),
))
conflict_response = conflict_request.send().response
assert_response_with_error(conflict_response, HTTPStatus.CONFLICT)
def endpoint_registry_address(deploy_client,
contract_manager) -> typing.Address:
address = deploy_contract_web3(
contract_name=CONTRACT_ENDPOINT_REGISTRY,
deploy_client=deploy_client,
contract_manager=contract_manager,
)
return address
def run_test_set_deposit_limit_crash(
raiden_network,
token_amount,
contract_manager,
retry_timeout,
):
app1 = raiden_network[0]
registry_address = app1.raiden.default_registry.address
token_address = deploy_contract_web3(
contract_name=CONTRACT_HUMAN_STANDARD_TOKEN,
deploy_client=app1.raiden.chain.client,
contract_manager=contract_manager,
constructor_arguments=(
token_amount,
2,
'raiden',
'Rd',
),
)
api1 = RaidenAPI(app1.raiden)
assert token_address not in api1.get_tokens_list(registry_address)
api1.token_network_register(
registry_address=registry_address,
token_address=token_address,
channel_participant_deposit_limit=RED_EYES_PER_CHANNEL_PARTICIPANT_LIMIT,
token_network_deposit_limit=RED_EYES_PER_TOKEN_NETWORK_LIMIT,
)
exception = RuntimeError('Did not see the token registration within 30 seconds')
with gevent.Timeout(seconds=30, exception=exception):
wait_for_state_change(
app1.raiden,
ContractReceiveNewTokenNetwork,
{
'token_network': {
'token_address': token_address,
},
},
retry_timeout,
)
assert token_address in api1.get_tokens_list(registry_address)
partner_address = make_address()
api1.channel_open(
registry_address=app1.raiden.default_registry.address,
token_address=token_address,
partner_address=partner_address,
)
with pytest.raises(DepositOverLimit):
api1.set_total_channel_deposit(
registry_address=app1.raiden.default_registry.address,
token_address=token_address,
partner_address=partner_address,
total_deposit=10000000000000000000000,
)
def deploy_secret_registry_and_return_address(
deploy_client: JSONRPCClient,
contract_manager: ContractManager) -> Address:
address = deploy_contract_web3(
contract_name=CONTRACT_SECRET_REGISTRY,
deploy_client=deploy_client,
contract_manager=contract_manager,
)
return address
def test_set_deposit_limit_crash(raiden_network, token_amount,
contract_manager, retry_timeout):
"""The development contracts as of 10/12/2018 were crashing if more than an amount was given
Regression test for https://github.com/raiden-network/raiden/issues/3135
"""
app1 = raiden_network[0]
registry_address = app1.raiden.default_registry.address
token_address = deploy_contract_web3(
contract_name=CONTRACT_HUMAN_STANDARD_TOKEN,
deploy_client=app1.raiden.chain.client,
contract_manager=contract_manager,
constructor_arguments=(
token_amount,
2,
'raiden',
'Rd',
),
)
api1 = RaidenAPI(app1.raiden)
assert token_address not in api1.get_tokens_list(registry_address)
api1.token_network_register(registry_address, token_address)
exception = RuntimeError(
'Did not see the token registration within 30 seconds')
with gevent.Timeout(seconds=30, exception=exception):
wait_for_state_change(
app1.raiden,
ContractReceiveNewTokenNetwork,
{
'token_network': {
'token_address': token_address,
},
},
retry_timeout,
)
assert token_address in api1.get_tokens_list(registry_address)
partner_address = make_address()
api1.channel_open(
registry_address=app1.raiden.default_registry.address,
token_address=token_address,
partner_address=partner_address,
)
with pytest.raises(DepositOverLimit):
api1.set_total_channel_deposit(
registry_address=app1.raiden.default_registry.address,
token_address=token_address,
partner_address=partner_address,
total_deposit=10000000000000000000000,
)
def deploy_smoketest_contracts(client):
addresses = deploy_contracts(client)
client.web3.personal.unlockAccount(
client.web3.eth.accounts[0],
TEST_ACCOUNT_PASSWORD,
)
for contract_name in NEW_CONTRACTS_TO_DEPLOY:
contract_address = deploy_contract_web3(contract_name, client)
addresses[contract_name] = contract_address
return addresses
def test_token_registered_race(raiden_chain, token_amount, retry_timeout,
contract_manager):
"""If a token is registered it must appear on the token list.
If two nodes register the same token one of the transactions will fail. The
node that receives an error for "already registered token" must see the
token in the token list. Issue: #784
"""
app0, app1 = raiden_chain
api0 = RaidenAPI(app0.raiden)
api1 = RaidenAPI(app1.raiden)
# Recreate the race condition by making sure the non-registering app won't
# register at all by watching for the TokenAdded blockchain event.
event_listeners = app1.raiden.blockchain_events.event_listeners
app1.raiden.blockchain_events.event_listeners = list()
token_address = deploy_contract_web3(
contract_name=CONTRACT_HUMAN_STANDARD_TOKEN,
deploy_client=app1.raiden.chain.client,
contract_manager=contract_manager,
num_confirmations=None,
constructor_arguments=(
token_amount,
2,
'raiden',
'Rd',
),
)
gevent.sleep(1)
registry_address = app0.raiden.default_registry.address
assert token_address not in api0.get_tokens_list(registry_address)
assert token_address not in api1.get_tokens_list(registry_address)
api0.token_network_register(registry_address, token_address)
gevent.sleep(1)
assert token_address in api0.get_tokens_list(registry_address)
assert token_address not in api1.get_tokens_list(registry_address)
# The next time when the event is polled, the token is registered
app1.raiden.blockchain_events.event_listeners = event_listeners
waiting.wait_for_block(
app1.raiden,
app1.raiden.get_block_number() + 1,
retry_timeout,
)
assert token_address in api1.get_tokens_list(registry_address)
def deploy_smoketest_contracts(client, chain_id, contract_manager):
client.web3.personal.unlockAccount(
client.web3.eth.accounts[0],
DEFAULT_PASSPHRASE,
)
endpoint_registry_address = deploy_contract_web3(
contract_name=CONTRACT_ENDPOINT_REGISTRY,
deploy_client=client,
contract_manager=contract_manager,
num_confirmations=None,
)
secret_registry_address = deploy_contract_web3(
contract_name=CONTRACT_SECRET_REGISTRY,
deploy_client=client,
contract_manager=contract_manager,
num_confirmations=1,
)
token_network_registry_address = deploy_contract_web3(
contract_name=CONTRACT_TOKEN_NETWORK_REGISTRY,
deploy_client=client,
contract_manager=contract_manager,
num_confirmations=None,
constructor_arguments=(
to_checksum_address(secret_registry_address),
chain_id,
TEST_SETTLE_TIMEOUT_MIN,
TEST_SETTLE_TIMEOUT_MAX,
),
)
addresses = {
CONTRACT_ENDPOINT_REGISTRY: endpoint_registry_address,
CONTRACT_SECRET_REGISTRY: secret_registry_address,
CONTRACT_TOKEN_NETWORK_REGISTRY: token_network_registry_address,
}
return addresses
def test_set_deposit_limit_crash(raiden_network, token_amount, contract_manager, retry_timeout):
"""The development contracts as of 10/12/2018 were crashing if more than an amount was given
Regression test for https://github.com/raiden-network/raiden/issues/3135
"""
app1 = raiden_network[0]
registry_address = app1.raiden.default_registry.address
token_address = deploy_contract_web3(
contract_name=CONTRACT_HUMAN_STANDARD_TOKEN,
deploy_client=app1.raiden.chain.client,
contract_manager=contract_manager,
constructor_arguments=(
token_amount,
2,
'raiden',
'Rd',
),
)
api1 = RaidenAPI(app1.raiden)
assert token_address not in api1.get_tokens_list(registry_address)
api1.token_network_register(registry_address, token_address)
exception = RuntimeError('Did not see the token registration within 30 seconds')
with gevent.Timeout(seconds=30, exception=exception):
wait_for_state_change(
app1.raiden,
ContractReceiveNewTokenNetwork,
{
'token_network': {
'token_address': token_address,
},
},
retry_timeout,
)
assert token_address in api1.get_tokens_list(registry_address)
partner_address = make_address()
api1.channel_open(
registry_address=app1.raiden.default_registry.address,
token_address=token_address,
partner_address=partner_address,
)
with pytest.raises(DepositOverLimit):
api1.set_total_channel_deposit(
registry_address=app1.raiden.default_registry.address,
token_address=token_address,
partner_address=partner_address,
total_deposit=10000000000000000000000,
)
def deploy_smoketest_contracts(client, chain_id):
client.web3.personal.unlockAccount(
client.web3.eth.accounts[0],
TEST_ACCOUNT_PASSWORD,
)
endpoint_registry_address = deploy_contract_web3(
CONTRACT_ENDPOINT_REGISTRY,
client,
num_confirmations=None,
)
secret_registry_address = deploy_contract_web3(
CONTRACT_SECRET_REGISTRY,
client,
num_confirmations=1,
)
token_network_registry_address = deploy_contract_web3(
CONTRACT_TOKEN_NETWORK_REGISTRY,
client,
num_confirmations=None,
constructor_arguments=(
to_checksum_address(secret_registry_address),
chain_id,
TEST_SETTLE_TIMEOUT_MIN,
TEST_SETTLE_TIMEOUT_MAX,
),
)
addresses = {
CONTRACT_ENDPOINT_REGISTRY: endpoint_registry_address,
CONTRACT_SECRET_REGISTRY: secret_registry_address,
CONTRACT_TOKEN_NETWORK_REGISTRY: token_network_registry_address,
}
return addresses
def maybe_deploy_service_registry_and_return_address(
deploy_client, contract_manager, token_proxy,
environment_type) -> Optional[typing.Address]:
if environment_type == Environment.PRODUCTION:
return None
# Not sure what to put in the registration fee token for testing, so using
# the same token we use for testing for now
constructor_arguments = (token_proxy.address, )
address = deploy_contract_web3(
contract_name=CONTRACT_SERVICE_REGISTRY,
deploy_client=deploy_client,
contract_manager=contract_manager,
constructor_arguments=constructor_arguments,
)
return address
def test_register_token(raiden_network, token_amount, contract_manager, retry_timeout):
app1 = raiden_network[0]
registry_address = app1.raiden.default_registry.address
token_address = deploy_contract_web3(
contract_name=CONTRACT_HUMAN_STANDARD_TOKEN,
deploy_client=app1.raiden.rpc_client,
contract_manager=contract_manager,
constructor_arguments=(token_amount, 2, "raiden", "Rd"),
)
# 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.
waiting.wait_for_block(
raiden=app1.raiden,
block_number=app1.raiden.get_block_number() + DEFAULT_NUMBER_OF_BLOCK_CONFIRMATIONS + 1,
retry_timeout=retry_timeout,
)
api1 = RaidenAPI(app1.raiden)
assert token_address not in api1.get_tokens_list(registry_address)
api1.token_network_register(
registry_address=registry_address,
token_address=token_address,
channel_participant_deposit_limit=UINT256_MAX,
token_network_deposit_limit=UINT256_MAX,
)
exception = RuntimeError("Did not see the token registration within 30 seconds")
with gevent.Timeout(seconds=30, exception=exception):
wait_for_state_change(
app1.raiden,
ContractReceiveNewTokenNetwork,
{"token_network": {"token_address": token_address}},
retry_timeout,
)
assert token_address in api1.get_tokens_list(registry_address)
# Exception if we try to reregister
with pytest.raises(AlreadyRegisteredTokenAddress):
api1.token_network_register(
registry_address=registry_address,
token_address=token_address,
channel_participant_deposit_limit=UINT256_MAX,
token_network_deposit_limit=UINT256_MAX,
)
def run_test_register_token(raiden_network, token_amount, contract_manager, retry_timeout):
app1 = raiden_network[0]
registry_address = app1.raiden.default_registry.address
token_address = deploy_contract_web3(
contract_name=CONTRACT_HUMAN_STANDARD_TOKEN,
deploy_client=app1.raiden.chain.client,
contract_manager=contract_manager,
constructor_arguments=(
token_amount,
2,
'raiden',
'Rd',
),
)
api1 = RaidenAPI(app1.raiden)
assert token_address not in api1.get_tokens_list(registry_address)
api1.token_network_register(
registry_address=registry_address,
token_address=token_address,
channel_participant_deposit_limit=UINT256_MAX,
token_network_deposit_limit=UINT256_MAX,
)
exception = RuntimeError('Did not see the token registration within 30 seconds')
with gevent.Timeout(seconds=30, exception=exception):
wait_for_state_change(
app1.raiden,
ContractReceiveNewTokenNetwork,
{
'token_network': {
'token_address': token_address,
},
},
retry_timeout,
)
assert token_address in api1.get_tokens_list(registry_address)
# Exception if we try to reregister
with pytest.raises(AlreadyRegisteredTokenAddress):
api1.token_network_register(
registry_address=registry_address,
token_address=token_address,
channel_participant_deposit_limit=UINT256_MAX,
token_network_deposit_limit=UINT256_MAX,
)
def deploy_one_to_n_and_return_address(
user_deposit_address, deploy_client, contract_manager,
environment_type, chain_id) -> typing.Optional[typing.Address]:
""" Deploy OneToN contract and return the address """
if environment_type != Environment.DEVELOPMENT:
return None
constructor_arguments = [user_deposit_address, chain_id]
one_to_n_address = deploy_contract_web3(
contract_name=CONTRACT_ONE_TO_N,
deploy_client=deploy_client,
contract_manager=contract_manager,
constructor_arguments=constructor_arguments,
)
return one_to_n_address
def token_network_registry_address(
deploy_client,
secret_registry_address,
chain_id,
settle_timeout_min,
settle_timeout_max,
) -> typing.Address:
address = deploy_contract_web3(
CONTRACT_TOKEN_NETWORK_REGISTRY,
deploy_client,
to_checksum_address(secret_registry_address),
chain_id,
settle_timeout_min,
settle_timeout_max,
)
return address
def token_network_registry_address(
deploy_client,
secret_registry_address,
chain_id,
settle_timeout_min,
settle_timeout_max,
) -> typing.Address:
address = deploy_contract_web3(
CONTRACT_TOKEN_NETWORK_REGISTRY,
deploy_client,
num_confirmations=None,
constructor_arguments=(
to_checksum_address(secret_registry_address),
chain_id,
settle_timeout_min,
settle_timeout_max,
),
)
return address
def test_register_token(raiden_network, token_amount, contract_manager, retry_timeout):
app1 = raiden_network[0]
registry_address = app1.raiden.default_registry.address
token_address = deploy_contract_web3(
contract_name=CONTRACT_HUMAN_STANDARD_TOKEN,
deploy_client=app1.raiden.chain.client,
contract_manager=contract_manager,
constructor_arguments=(
token_amount,
2,
'raiden',
'Rd',
),
)
api1 = RaidenAPI(app1.raiden)
assert token_address not in api1.get_tokens_list(registry_address)
api1.token_network_register(registry_address, token_address)
exception = RuntimeError('Did not see the token registration within 30 seconds')
with gevent.Timeout(seconds=30, exception=exception):
wait_for_state_change(
app1.raiden,
ContractReceiveNewTokenNetwork,
{
'token_network': {
'token_address': token_address,
},
},
retry_timeout,
)
assert token_address in api1.get_tokens_list(registry_address)
# Exception if we try to reregister
with pytest.raises(AlreadyRegisteredTokenAddress):
api1.token_network_register(registry_address, token_address)
def test_endpointregistry(private_keys, blockchain_services):
chain = blockchain_services.blockchain_services[0]
my_address = privatekey_to_address(private_keys[0])
endpointregistry_address = deploy_contract_web3(
CONTRACT_ENDPOINT_REGISTRY,
chain.client,
num_confirmations=None,
)
discovery_proxy = chain.discovery(endpointregistry_address)
contract_discovery = ContractDiscovery(my_address, discovery_proxy)
unregistered_address = make_address()
# get should raise for unregistered addresses
with pytest.raises(UnknownAddress):
contract_discovery.get(my_address)
with pytest.raises(UnknownAddress):
contract_discovery.get(unregistered_address)
assert contract_discovery.nodeid_by_host_port(('127.0.0.1', 44444)) is None
contract_discovery.register(my_address, '127.0.0.1', 44444)
assert contract_discovery.nodeid_by_host_port(('127.0.0.1', 44444)) == my_address
assert contract_discovery.get(my_address) == ('127.0.0.1', 44444)
contract_discovery.register(my_address, '127.0.0.1', 88888)
assert contract_discovery.nodeid_by_host_port(('127.0.0.1', 88888)) == my_address
assert contract_discovery.get(my_address) == ('127.0.0.1', 88888)
with pytest.raises(UnknownAddress):
contract_discovery.get(unregistered_address)
def test_token_registered_race(raiden_chain, token_amount, retry_timeout, contract_manager):
"""If a token is registered it must appear on the token list.
If two nodes register the same token one of the transactions will fail. The
node that receives an error for "already registered token" must see the
token in the token list. Issue: #784
"""
app0, app1 = raiden_chain
api0 = RaidenAPI(app0.raiden)
api1 = RaidenAPI(app1.raiden)
# Recreate the race condition by making sure the non-registering app won't
# register at all by watching for the TokenAdded blockchain event.
event_listeners = app1.raiden.blockchain_events.event_listeners
app1.raiden.blockchain_events.event_listeners = list()
token_address = deploy_contract_web3(
contract_name=CONTRACT_HUMAN_STANDARD_TOKEN,
deploy_client=app1.raiden.chain.client,
contract_manager=contract_manager,
constructor_arguments=(
token_amount,
2,
'raiden',
'Rd',
),
)
gevent.sleep(1)
registry_address = app0.raiden.default_registry.address
assert token_address not in api0.get_tokens_list(registry_address)
assert token_address not in api1.get_tokens_list(registry_address)
api0.token_network_register(registry_address, token_address)
exception = RuntimeError('Did not see the token registration within 30 seconds')
with gevent.Timeout(seconds=30, exception=exception):
wait_for_state_change(
app0.raiden,
ContractReceiveNewTokenNetwork,
{
'token_network': {
'token_address': token_address,
},
},
retry_timeout,
)
assert token_address in api0.get_tokens_list(registry_address)
assert token_address not in api1.get_tokens_list(registry_address)
# The next time when the event is polled, the token is registered
app1.raiden.blockchain_events.event_listeners = event_listeners
waiting.wait_for_block(
app1.raiden,
app1.raiden.get_block_number() + 1,
retry_timeout,
)
assert token_address in api1.get_tokens_list(registry_address)
