def registry(self, registry_address: Address) -> Registry:
if not is_binary_address(registry_address):
raise ValueError('registry_address must be a valid address')
if registry_address not in self.address_to_registry:
self.address_to_registry[registry_address] = Registry(
self.client,
registry_address,
)
return self.address_to_registry[registry_address]
def registry(self, registry_address: bytes) -> Registry:
if not isaddress(registry_address):
raise ValueError('registry_address must be a valid address')
if registry_address not in self.address_to_registry:
self.address_to_registry[registry_address] = Registry(
self.client,
registry_address,
self.poll_timeout,
)
return self.address_to_registry[registry_address]
def test_blockchain(
init_blockchain,
web3,
blockchain_rpc_ports,
private_keys,
poll_timeout):
# pylint: disable=too-many-locals
addresses = [
privatekey_to_address(priv)
for priv in private_keys
]
privatekey = private_keys[0]
address = privatekey_to_address(privatekey)
total_token = 100
host = '127.0.0.1'
jsonrpc_client = JSONRPCClient(
host,
blockchain_rpc_ports[0],
privatekey,
web3=web3,
)
humantoken_path = get_contract_path('HumanStandardToken.sol')
humantoken_contracts = compile_files_cwd([humantoken_path])
token_proxy = jsonrpc_client.deploy_solidity_contract(
'HumanStandardToken',
humantoken_contracts,
list(),
(total_token, 'raiden', 2, 'Rd'),
contract_path=humantoken_path,
timeout=poll_timeout,
)
token_proxy = Token(jsonrpc_client, to_canonical_address(token_proxy.contract.address))
registry_path = get_contract_path('Registry.sol')
registry_contracts = compile_files_cwd([registry_path])
registry_proxy = jsonrpc_client.deploy_solidity_contract(
'Registry',
registry_contracts,
list(),
tuple(),
contract_path=registry_path,
timeout=poll_timeout,
)
registry_proxy = Registry(
jsonrpc_client,
to_canonical_address(registry_proxy.contract.address),
)
log_list = jsonrpc_client.web3.eth.getLogs(
{
'fromBlock': 0,
'toBlock': 'latest',
'topics': [],
},
)
assert not log_list
assert token_proxy.balance_of(address) == total_token
manager_address = registry_proxy.add_token(
to_canonical_address(token_proxy.proxy.contract.address),
)
assert is_address(manager_address)
assert len(registry_proxy.token_addresses()) == 1
log_list = jsonrpc_client.web3.eth.getLogs(
{
'fromBlock': 0,
'toBlock': 'latest',
'topics': [],
},
)
assert len(log_list) == 1
channel_manager_address_encoded = registry_proxy.manager_address_by_token(
token_proxy.proxy.contract.address,
)
channel_manager_address = to_canonical_address(channel_manager_address_encoded)
log = log_list[0]
event = decode_event(CONTRACT_MANAGER.get_contract_abi(CONTRACT_REGISTRY), log)
event_args = event['args']
assert channel_manager_address == to_canonical_address(event_args['channel_manager_address'])
assert is_same_address(token_proxy.proxy.contract.address, event_args['token_address'])
channel_manager_proxy = jsonrpc_client.new_contract_proxy(
CONTRACT_MANAGER.get_contract_abi(CONTRACT_CHANNEL_MANAGER),
channel_manager_address,
)
channel_manager_proxy = ChannelManager(
jsonrpc_client,
to_canonical_address(channel_manager_proxy.contract.address),
)
channel_address = channel_manager_proxy.new_netting_channel(
addresses[1],
10,
)
assert is_address(channel_address)
log_list = jsonrpc_client.web3.eth.getLogs(
{
'fromBlock': 0,
'toBlock': 'latest',
'topics': [],
},
)
assert len(log_list) == 2
