def register_token_and_return_the_network_proxy(
contract_manager,
deploy_client,
token_proxy,
token_network_registry_address,
):
registry_address = to_canonical_address(token_network_registry_address)
token_network_registry_proxy = TokenNetworkRegistry(
jsonrpc_client=deploy_client,
registry_address=registry_address,
contract_manager=contract_manager,
)
token_network_address = token_network_registry_proxy.add_token_with_limits(
token_address=token_proxy.address,
channel_participant_deposit_limit=
RED_EYES_PER_CHANNEL_PARTICIPANT_LIMIT,
token_network_deposit_limit=RED_EYES_PER_TOKEN_NETWORK_LIMIT,
)
return TokenNetwork(
jsonrpc_client=deploy_client,
token_network_address=token_network_address,
contract_manager=contract_manager,
)
def __init__(
self,
config: RaidenConfig,
rpc_client: JSONRPCClient,
proxy_manager: ProxyManager,
query_start_block: BlockNumber,
default_registry: TokenNetworkRegistry,
default_secret_registry: SecretRegistry,
default_service_registry: Optional[ServiceRegistry],
default_user_deposit: Optional[UserDeposit],
default_one_to_n_address: Optional[OneToNAddress],
default_msc_address: Optional[MonitoringServiceAddress],
transport: MatrixTransport,
raiden_event_handler: EventHandler,
message_handler: MessageHandler,
routing_mode: RoutingMode,
api_server: APIServer = None,
):
raiden = RaidenService(
rpc_client=rpc_client,
proxy_manager=proxy_manager,
query_start_block=query_start_block,
default_registry=default_registry,
default_secret_registry=default_secret_registry,
default_service_registry=default_service_registry,
default_user_deposit=default_user_deposit,
default_one_to_n_address=default_one_to_n_address,
default_msc_address=default_msc_address,
transport=transport,
raiden_event_handler=raiden_event_handler,
message_handler=message_handler,
routing_mode=routing_mode,
config=config,
api_server=api_server,
)
# check that the settlement timeout fits the limits of the contract
settlement_timeout_min = default_registry.settlement_timeout_min(BLOCK_ID_LATEST)
settlement_timeout_max = default_registry.settlement_timeout_max(BLOCK_ID_LATEST)
invalid_settle_timeout = (
config.settle_timeout < settlement_timeout_min
or config.settle_timeout > settlement_timeout_max
or config.settle_timeout < config.reveal_timeout * 2
)
if invalid_settle_timeout:
raise InvalidSettleTimeout(
(
"Settlement timeout for Registry contract {} must "
"be in range [{}, {}], is {}"
).format(
to_checksum_address(default_registry.address),
settlement_timeout_min,
settlement_timeout_max,
config.settle_timeout,
)
)
self.config = config
self.raiden = raiden
def __init__(
self,
config: typing.Dict,
rpc_client: JSONRPCClient,
proxy_manager: ProxyManager,
query_start_block: typing.BlockNumber,
default_registry: TokenNetworkRegistry,
default_secret_registry: SecretRegistry,
default_service_registry: typing.Optional[ServiceRegistry],
default_one_to_n_address: typing.Optional[Address],
default_msc_address: Address,
transport: MatrixTransport,
raiden_event_handler: EventHandler,
message_handler: MessageHandler,
routing_mode: RoutingMode,
user_deposit: UserDeposit = None,
):
raiden = RaidenService(
rpc_client=rpc_client,
proxy_manager=proxy_manager,
query_start_block=query_start_block,
default_registry=default_registry,
default_one_to_n_address=default_one_to_n_address,
default_secret_registry=default_secret_registry,
default_service_registry=default_service_registry,
default_msc_address=default_msc_address,
transport=transport,
raiden_event_handler=raiden_event_handler,
message_handler=message_handler,
routing_mode=routing_mode,
config=config,
user_deposit=user_deposit,
)
# check that the settlement timeout fits the limits of the contract
settlement_timeout_min = default_registry.settlement_timeout_min("latest")
settlement_timeout_max = default_registry.settlement_timeout_max("latest")
invalid_settle_timeout = (
config["settle_timeout"] < settlement_timeout_min
or config["settle_timeout"] > settlement_timeout_max
or config["settle_timeout"] < config["reveal_timeout"] * 2
)
if invalid_settle_timeout:
raise InvalidSettleTimeout(
(
"Settlement timeout for Registry contract {} must "
"be in range [{}, {}], is {}"
).format(
to_checksum_address(default_registry.address),
settlement_timeout_min,
settlement_timeout_max,
config["settle_timeout"],
)
)
self.config = config
self.user_deposit = user_deposit
self.raiden = raiden
def __init__(
self,
config: typing.Dict,
chain: BlockChainService,
query_start_block: typing.BlockNumber,
default_registry: TokenNetworkRegistry,
default_secret_registry: SecretRegistry,
default_service_registry: typing.Optional[ServiceRegistry],
transport,
raiden_event_handler,
message_handler,
discovery: Discovery = None,
user_deposit: UserDeposit = None,
):
raiden = RaidenService(
chain=chain,
query_start_block=query_start_block,
default_registry=default_registry,
default_secret_registry=default_secret_registry,
default_service_registry=default_service_registry,
transport=transport,
raiden_event_handler=raiden_event_handler,
message_handler=message_handler,
config=config,
discovery=discovery,
user_deposit=user_deposit,
)
# check that the settlement timeout fits the limits of the contract
invalid_settle_timeout = (
config['settle_timeout'] < default_registry.settlement_timeout_min() or
config['settle_timeout'] > default_registry.settlement_timeout_max() or
config['settle_timeout'] < config['reveal_timeout'] * 2
)
if invalid_settle_timeout:
raise InvalidSettleTimeout(
(
'Settlement timeout for Registry contract {} must '
'be in range [{}, {}], is {}'
).format(
to_checksum_address(default_registry.address),
default_registry.settlement_timeout_min(),
default_registry.settlement_timeout_max(),
config['settle_timeout'],
),
)
self.config = config
self.discovery = discovery
self.user_deposit = user_deposit
self.raiden = raiden
self.start_console = self.config['console']
# raiden.ui.console:Console assumes that a services
# attribute is available for auto-registration
self.services = dict()
def token_network_registry(
self,
address: TokenNetworkRegistryAddress) -> TokenNetworkRegistry:
with self._token_network_registry_creation_lock:
if address not in self.address_to_token_network_registry:
metadata = SmartContractMetadata(
deployed_at=self.metadata.
token_network_registry_deployed_at,
address=Address(address),
abi=self.contract_manager.get_contract_abi(
CONTRACT_TOKEN_NETWORK_REGISTRY),
runtime_bytecode=EVMBytecode(
decode_hex(
self.contract_manager.get_runtime_hexcode(
CONTRACT_TOKEN_NETWORK_REGISTRY))),
gas_measurements=gas_measurements(
self.contract_manager.contracts_version),
filters_start_at=self.metadata.filters_start_at,
)
self.address_to_token_network_registry[
address] = TokenNetworkRegistry(rpc_client=self.client,
metadata=metadata,
proxy_manager=self)
return self.address_to_token_network_registry[address]
def maybe_create_token_network(
token_network_proxy: TokenNetworkRegistry,
token_proxy: CustomToken) -> TokenNetworkAddress:
""" Make sure the token is registered with the node's network registry. """
block_identifier = token_network_proxy.rpc_client.get_confirmed_blockhash()
token_address = token_proxy.address
token_network_address = token_network_proxy.get_token_network(
token_address=token_address, block_identifier=block_identifier)
if token_network_address is None:
_, new_token_network_address = token_network_proxy.add_token(
token_address=token_address,
channel_participant_deposit_limit=TokenAmount(UINT256_MAX),
token_network_deposit_limit=TokenAmount(UINT256_MAX),
given_block_identifier=block_identifier,
)
return new_token_network_address
else:
return token_network_address
def token_network_registry(self, address: Address) -> TokenNetworkRegistry:
if not is_binary_address(address):
raise ValueError("address must be a valid address")
with self._token_network_registry_creation_lock:
if address not in self.address_to_token_network_registry:
self.address_to_token_network_registry[
address] = TokenNetworkRegistry(
jsonrpc_client=self.client,
registry_address=PaymentNetworkID(address),
contract_manager=self.contract_manager,
)
return self.address_to_token_network_registry[address]
def add_token_network_registry_listener(
self,
token_network_registry_proxy: TokenNetworkRegistry,
contract_manager: ContractManager,
from_block: BlockNumber,
) -> None:
token_new_filter = token_network_registry_proxy.tokenadded_filter(from_block=from_block)
token_network_registry_address = token_network_registry_proxy.address
self.add_event_listener(
"TokenNetworkRegistry {}".format(to_checksum_address(token_network_registry_address)),
token_new_filter,
contract_manager.get_contract_abi(CONTRACT_TOKEN_NETWORK_REGISTRY),
)
def test_token_network_registry(
deploy_client,
contract_manager,
token_network_registry_proxy: TokenNetworkRegistry,
):
assert token_network_registry_proxy.settlement_timeout_min() == TEST_SETTLE_TIMEOUT_MIN
assert token_network_registry_proxy.settlement_timeout_max() == TEST_SETTLE_TIMEOUT_MAX
bad_token_address = make_address()
# try to register non-existing token network
with pytest.raises(RaidenUnrecoverableError):
token_network_registry_proxy.add_token(bad_token_address)
# create token network & register it
test_token = deploy_token(
deploy_client=deploy_client,
contract_manager=contract_manager,
initial_amount=1000,
decimals=0,
token_name='TKN',
token_symbol='TKN',
)
test_token_address = to_canonical_address(test_token.contract.address)
event_filter = token_network_registry_proxy.tokenadded_filter()
token_network_address = token_network_registry_proxy.add_token(
test_token_address,
)
with pytest.raises(RaidenRecoverableError) as exc:
token_network_address = token_network_registry_proxy.add_token(
test_token_address,
)
assert 'Token already registered' in str(exc)
logs = event_filter.get_all_entries()
assert len(logs) == 1
decoded_event = token_network_registry_proxy.proxy.decode_event(logs[0])
assert is_same_address(decoded_event['args']['token_address'], test_token.contract.address)
assert is_same_address(
decoded_event['args']['token_network_address'],
token_network_address,
)
# test other getters
assert token_network_registry_proxy.get_token_network(bad_token_address) is None
assert is_same_address(
token_network_registry_proxy.get_token_network(test_token_address),
token_network_address,
)
with pytest.raises(ValueError):
assert token_network_registry_proxy.get_token_network(None) is None
assert token_network_registry_proxy.get_token_network(bad_token_address) is None
assert token_network_registry_proxy.get_token_network(token_network_address) is None
assert token_network_registry_proxy.get_token_network(test_token_address) is not None
def test_token_network_registry(
deploy_client,
contract_manager,
token_network_registry_proxy: TokenNetworkRegistry,
):
assert token_network_registry_proxy.settlement_timeout_min(
) == TEST_SETTLE_TIMEOUT_MIN
assert token_network_registry_proxy.settlement_timeout_max(
) == TEST_SETTLE_TIMEOUT_MAX
bad_token_address = make_address()
# try to register non-existing token network
with pytest.raises(TransactionThrew):
token_network_registry_proxy.add_token(bad_token_address)
# create token network & register it
test_token = deploy_token(
deploy_client=deploy_client,
contract_manager=contract_manager,
initial_amount=1000,
decimals=0,
token_name='TKN',
token_symbol='TKN',
)
test_token_address = to_canonical_address(test_token.contract.address)
event_filter = token_network_registry_proxy.tokenadded_filter()
token_network_address = token_network_registry_proxy.add_token(
test_token_address, )
with pytest.raises(RaidenRecoverableError) as exc:
token_network_address = token_network_registry_proxy.add_token(
test_token_address, )
assert 'Token already registered' in str(exc)
logs = event_filter.get_all_entries()
assert len(logs) == 1
decoded_event = token_network_registry_proxy.proxy.decode_event(logs[0])
assert is_same_address(decoded_event['args']['token_address'],
test_token.contract.address)
assert is_same_address(
decoded_event['args']['token_network_address'],
token_network_address,
)
# test other getters
assert token_network_registry_proxy.get_token_network(
bad_token_address) is None
assert is_same_address(
token_network_registry_proxy.get_token_network(test_token_address),
token_network_address,
)
with pytest.raises(ValueError):
assert token_network_registry_proxy.get_token_network(None) is None
assert token_network_registry_proxy.get_token_network(
bad_token_address) is None
assert token_network_registry_proxy.get_token_network(
token_network_address) is None
assert token_network_registry_proxy.get_token_network(
test_token_address) is not None
def setup_raiden(
transport,
matrix_server,
print_step,
contracts_version,
testchain_setup,
):
print_step('Deploying Raiden contracts')
if testchain_setup['eth_client'] is EthClient.PARITY:
client = JSONRPCClient(
testchain_setup['web3'],
get_private_key(testchain_setup['keystore']),
gas_estimate_correction=lambda gas: gas * 2,
)
else:
client = JSONRPCClient(
testchain_setup['web3'],
get_private_key(testchain_setup['keystore']),
)
contract_manager = ContractManager(
contracts_precompiled_path(contracts_version), )
token = deploy_token(
deploy_client=client,
contract_manager=contract_manager,
initial_amount=1000,
decimals=0,
token_name='TKN',
token_symbol='TKN',
)
contract_addresses = deploy_smoketest_contracts(
client=client,
chain_id=NETWORKNAME_TO_ID['smoketest'],
contract_manager=contract_manager,
token_address=to_canonical_address(token.contract.address),
)
registry = TokenNetworkRegistry(
jsonrpc_client=client,
registry_address=contract_addresses[CONTRACT_TOKEN_NETWORK_REGISTRY],
contract_manager=contract_manager,
)
if contracts_version == DEVELOPMENT_CONTRACT_VERSION:
registry.add_token_with_limits(
token_address=to_canonical_address(token.contract.address),
channel_participant_deposit_limit=
RED_EYES_PER_CHANNEL_PARTICIPANT_LIMIT,
token_network_deposit_limit=RED_EYES_PER_TOKEN_NETWORK_LIMIT,
)
else:
registry.add_token_without_limits(token_address=to_canonical_address(
token.contract.address), )
print_step('Setting up Raiden')
endpoint_registry_contract_address = to_checksum_address(
contract_addresses[CONTRACT_ENDPOINT_REGISTRY], )
tokennetwork_registry_contract_address = to_checksum_address(
contract_addresses[CONTRACT_TOKEN_NETWORK_REGISTRY], )
secret_registry_contract_address = to_checksum_address(
contract_addresses[CONTRACT_SECRET_REGISTRY], )
args = {
'address':
to_checksum_address(TEST_ACCOUNT_ADDRESS),
'datadir':
testchain_setup['keystore'],
'endpoint_registry_contract_address':
endpoint_registry_contract_address,
'eth_rpc_endpoint':
testchain_setup['eth_rpc_endpoint'],
'gas_price':
'fast',
'keystore_path':
testchain_setup['keystore'],
'matrix_server':
matrix_server,
'network_id':
str(NETWORKNAME_TO_ID['smoketest']),
'password_file':
click.File()(os.path.join(testchain_setup['base_datadir'], 'pw')),
'tokennetwork_registry_contract_address':
tokennetwork_registry_contract_address,
'secret_registry_contract_address':
secret_registry_contract_address,
'sync_check':
False,
'transport':
transport,
}
if contracts_version == DEVELOPMENT_CONTRACT_VERSION:
service_registry_contract_address = to_checksum_address(
contract_addresses[CONTRACT_SERVICE_REGISTRY], )
args[
'service_registry_contract_address'] = service_registry_contract_address
return {
'args': args,
'contract_addresses': contract_addresses,
'ethereum_nodes': testchain_setup['node_executors'],
'token': token,
}
def test_token_network_registry(
deploy_client,
contract_manager,
token_network_registry_address,
):
registry_address = to_canonical_address(token_network_registry_address)
token_network_registry_proxy = TokenNetworkRegistry(
jsonrpc_client=deploy_client,
registry_address=registry_address,
contract_manager=contract_manager,
)
assert token_network_registry_proxy.settlement_timeout_min(
) == TEST_SETTLE_TIMEOUT_MIN
assert token_network_registry_proxy.settlement_timeout_max(
) == TEST_SETTLE_TIMEOUT_MAX
bad_token_address = make_address()
# try to register non-existing token network
with pytest.raises(AddressWithoutCode):
token_network_registry_proxy.add_token_with_limits(
token_address=bad_token_address,
channel_participant_deposit_limit=
RED_EYES_PER_CHANNEL_PARTICIPANT_LIMIT,
token_network_deposit_limit=RED_EYES_PER_TOKEN_NETWORK_LIMIT,
)
# create token network & register it
test_token = deploy_token(
deploy_client=deploy_client,
contract_manager=contract_manager,
initial_amount=1000,
decimals=0,
token_name='TKN',
token_symbol='TKN',
)
test_token_address = to_canonical_address(test_token.contract.address)
# try to register a token network not following ERC20 protocol
with patch.object(Token, 'total_supply', return_value=''):
with pytest.raises(InvalidToken):
token_network_registry_proxy.add_token_with_limits(
token_address=test_token_address,
channel_participant_deposit_limit=
RED_EYES_PER_CHANNEL_PARTICIPANT_LIMIT,
token_network_deposit_limit=RED_EYES_PER_TOKEN_NETWORK_LIMIT,
)
event_filter = token_network_registry_proxy.tokenadded_filter()
token_network_address = token_network_registry_proxy.add_token_with_limits(
token_address=test_token_address,
channel_participant_deposit_limit=
RED_EYES_PER_CHANNEL_PARTICIPANT_LIMIT,
token_network_deposit_limit=RED_EYES_PER_TOKEN_NETWORK_LIMIT,
)
with pytest.raises(RaidenRecoverableError) as exc:
token_network_address = token_network_registry_proxy.add_token_with_limits(
token_address=test_token_address,
channel_participant_deposit_limit=
RED_EYES_PER_CHANNEL_PARTICIPANT_LIMIT,
token_network_deposit_limit=RED_EYES_PER_TOKEN_NETWORK_LIMIT,
)
assert 'Token already registered' in str(exc)
logs = event_filter.get_all_entries()
assert len(logs) == 1
decoded_event = token_network_registry_proxy.proxy.decode_event(logs[0])
assert is_same_address(decoded_event['args']['token_address'],
test_token.contract.address)
assert is_same_address(
decoded_event['args']['token_network_address'],
token_network_address,
)
# test other getters
assert token_network_registry_proxy.get_token_network(
bad_token_address) is None
assert is_same_address(
token_network_registry_proxy.get_token_network(test_token_address),
token_network_address,
)
with pytest.raises(ValueError):
assert token_network_registry_proxy.get_token_network(None) is None
assert token_network_registry_proxy.get_token_network(
bad_token_address) is None
assert token_network_registry_proxy.get_token_network(
token_network_address) is None
assert token_network_registry_proxy.get_token_network(
test_token_address) is not None
def test_network_registry(token_network_registry_proxy: TokenNetworkRegistry, deploy_token):
assert token_network_registry_proxy.settlement_timeout_min() == TEST_SETTLE_TIMEOUT_MIN
assert token_network_registry_proxy.settlement_timeout_max() == TEST_SETTLE_TIMEOUT_MAX
bad_token_address = make_address()
# try to register non-existing token network
with pytest.raises(TransactionThrew):
token_network_registry_proxy.add_token(bad_token_address)
# create token network & register it
test_token = deploy_token(1000, 0, 'TKN', 'TKN')
test_token_address = to_canonical_address(test_token.contract.address)
event_filter = token_network_registry_proxy.tokenadded_filter()
token_network_address = token_network_registry_proxy.add_token(
test_token_address,
)
logs = event_filter.get_all_entries()
assert len(logs) == 1
decoded_event = token_network_registry_proxy.proxy.decode_event(logs[0])
assert is_same_address(decoded_event['args']['token_address'], test_token.contract.address)
assert is_same_address(
decoded_event['args']['token_network_address'],
token_network_address,
)
# test other getters
assert token_network_registry_proxy.get_token_network(bad_token_address) is None
assert is_same_address(
token_network_registry_proxy.get_token_network(test_token_address),
token_network_address,
)
with pytest.raises(ValueError):
assert token_network_registry_proxy.get_token_network(None) is None
assert token_network_registry_proxy.get_token_network(bad_token_address) is None
assert token_network_registry_proxy.get_token_network(token_network_address) is None
assert token_network_registry_proxy.get_token_network(test_token_address) is not None
def setup_raiden(transport, matrix_server, print_step, contracts_version,
testchain_setup):
print_step("Deploying Raiden contracts")
if testchain_setup["eth_client"] is EthClient.PARITY:
client = JSONRPCClient(
testchain_setup["web3"],
get_private_key(testchain_setup["keystore"]),
gas_estimate_correction=lambda gas: gas * 2,
)
else:
client = JSONRPCClient(testchain_setup["web3"],
get_private_key(testchain_setup["keystore"]))
contract_manager = ContractManager(
contracts_precompiled_path(contracts_version))
token = deploy_token(
deploy_client=client,
contract_manager=contract_manager,
initial_amount=1000,
decimals=0,
token_name="TKN",
token_symbol="TKN",
)
contract_addresses = deploy_smoketest_contracts(
client=client,
chain_id=NETWORKNAME_TO_ID["smoketest"],
contract_manager=contract_manager,
token_address=to_canonical_address(token.contract.address),
)
registry = TokenNetworkRegistry(
jsonrpc_client=client,
registry_address=contract_addresses[CONTRACT_TOKEN_NETWORK_REGISTRY],
contract_manager=contract_manager,
)
if contracts_version == DEVELOPMENT_CONTRACT_VERSION:
registry.add_token_with_limits(
token_address=to_canonical_address(token.contract.address),
channel_participant_deposit_limit=
RED_EYES_PER_CHANNEL_PARTICIPANT_LIMIT,
token_network_deposit_limit=RED_EYES_PER_TOKEN_NETWORK_LIMIT,
)
else:
registry.add_token_without_limits(
token_address=to_canonical_address(token.contract.address))
print_step("Setting up Raiden")
endpoint_registry_contract_address = to_checksum_address(
contract_addresses[CONTRACT_ENDPOINT_REGISTRY])
tokennetwork_registry_contract_address = to_checksum_address(
contract_addresses[CONTRACT_TOKEN_NETWORK_REGISTRY])
secret_registry_contract_address = to_checksum_address(
contract_addresses[CONTRACT_SECRET_REGISTRY])
args = {
"address":
to_checksum_address(TEST_ACCOUNT_ADDRESS),
"datadir":
testchain_setup["keystore"],
"endpoint_registry_contract_address":
endpoint_registry_contract_address,
"eth_rpc_endpoint":
testchain_setup["eth_rpc_endpoint"],
"gas_price":
"fast",
"keystore_path":
testchain_setup["keystore"],
"matrix_server":
matrix_server,
"network_id":
str(NETWORKNAME_TO_ID["smoketest"]),
"password_file":
click.File()(os.path.join(testchain_setup["base_datadir"], "pw")),
"tokennetwork_registry_contract_address":
tokennetwork_registry_contract_address,
"secret_registry_contract_address":
secret_registry_contract_address,
"sync_check":
False,
"transport":
transport,
}
if contracts_version == DEVELOPMENT_CONTRACT_VERSION:
service_registry_contract_address = to_checksum_address(
contract_addresses[CONTRACT_SERVICE_REGISTRY])
args[
"service_registry_contract_address"] = service_registry_contract_address
return {
"args": args,
"contract_addresses": contract_addresses,
"ethereum_nodes": testchain_setup["node_executors"],
"token": token,
}
def test_network_registry(token_network_registry_proxy: TokenNetworkRegistry,
deploy_token):
assert token_network_registry_proxy.settlement_timeout_min(
) == TEST_SETTLE_TIMEOUT_MIN
assert token_network_registry_proxy.settlement_timeout_max(
) == TEST_SETTLE_TIMEOUT_MAX
bad_token_address = make_address()
# try to register non-existing token network
with pytest.raises(TransactionThrew):
token_network_registry_proxy.add_token(bad_token_address)
# create token network & register it
test_token = deploy_token(1000, 0, 'TKN', 'TKN')
test_token_address = to_canonical_address(test_token.contract.address)
event_filter = token_network_registry_proxy.tokenadded_filter()
token_network_address = token_network_registry_proxy.add_token(
test_token_address, )
logs = event_filter.get_all_entries()
assert len(logs) == 1
decoded_event = token_network_registry_proxy.proxy.decode_event(logs[0])
assert is_same_address(decoded_event['args']['token_address'],
test_token.contract.address)
assert is_same_address(
decoded_event['args']['token_network_address'],
token_network_address,
)
# test other getters
assert token_network_registry_proxy.get_token_network(
bad_token_address) is None
assert is_same_address(
token_network_registry_proxy.get_token_network(test_token_address),
token_network_address,
)
with pytest.raises(AddressWithoutCode):
token_network_registry_proxy.token_network_by_token(bad_token_address)
with pytest.raises(InvalidAddress):
token_network_registry_proxy.token_network_by_token(None)
with pytest.raises(NoTokenManager):
token_network_registry_proxy.token_network_by_token(
token_network_address)
token_manager = token_network_registry_proxy.token_network_by_token(
test_token_address, )
assert token_manager is not None
