def __init__(
self,
jsonrpc_client,
secret_registry_address,
contract_manager: ContractManager,
):
if not is_binary_address(secret_registry_address):
raise InvalidAddress(
'Expected binary address format for secret registry')
self.contract_manager = contract_manager
check_address_has_code(jsonrpc_client, secret_registry_address,
CONTRACT_SECRET_REGISTRY)
proxy = jsonrpc_client.new_contract_proxy(
self.contract_manager.get_contract_abi(CONTRACT_SECRET_REGISTRY),
to_normalized_address(secret_registry_address),
)
compare_contract_versions(
proxy=proxy,
expected_version=contract_manager.contracts_version,
contract_name=CONTRACT_SECRET_REGISTRY,
address=secret_registry_address,
)
self.address = secret_registry_address
self.proxy = proxy
self.client = jsonrpc_client
self.node_address = privatekey_to_address(self.client.privkey)
self.open_secret_transactions = dict()
def __init__(
self,
jsonrpc_client: JSONRPCClient,
one_to_n_address: OneToNAddress,
contract_manager: ContractManager,
):
if not is_binary_address(one_to_n_address):
raise ValueError("Expected binary address for monitoring service")
self.contract_manager = contract_manager
check_address_has_code(
client=jsonrpc_client,
address=Address(one_to_n_address),
contract_name=CONTRACT_ONE_TO_N,
expected_code=decode_hex(contract_manager.get_runtime_hexcode(CONTRACT_ONE_TO_N)),
)
proxy = jsonrpc_client.new_contract_proxy(
abi=self.contract_manager.get_contract_abi(CONTRACT_ONE_TO_N),
contract_address=Address(one_to_n_address),
)
self.address = one_to_n_address
self.proxy = proxy
self.client = jsonrpc_client
self.node_address = self.client.address
def __init__(
self,
jsonrpc_client,
registry_address,
):
if not is_binary_address(registry_address):
raise InvalidAddress('Expected binary address format for token network registry')
check_address_has_code(jsonrpc_client, registry_address, CONTRACT_TOKEN_NETWORK_REGISTRY)
proxy = jsonrpc_client.new_contract_proxy(
CONTRACT_MANAGER.get_contract_abi(CONTRACT_TOKEN_NETWORK_REGISTRY),
to_normalized_address(registry_address),
)
is_valid_version = compare_versions(
proxy.contract.functions.contract_version().call(),
EXPECTED_CONTRACTS_VERSION,
)
if not is_valid_version:
raise ContractVersionMismatch('Incompatible ABI for TokenNetworkRegistry')
self.address = registry_address
self.proxy = proxy
self.client = jsonrpc_client
self.node_address = privatekey_to_address(self.client.privkey)
def __init__(
self,
jsonrpc_client,
discovery_address,
contract_manager: ContractManager,
):
contract = jsonrpc_client.new_contract(
contract_manager.get_contract_abi(CONTRACT_ENDPOINT_REGISTRY),
to_normalized_address(discovery_address),
)
proxy = ContractProxy(jsonrpc_client, contract)
if not is_binary_address(discovery_address):
raise ValueError('discovery_address must be a valid address')
check_address_has_code(jsonrpc_client, discovery_address, 'Discovery')
compare_contract_versions(
proxy=proxy,
expected_version=contract_manager.contracts_version,
contract_name=CONTRACT_ENDPOINT_REGISTRY,
address=discovery_address,
)
self.address = discovery_address
self.node_address = privatekey_to_address(jsonrpc_client.privkey)
self.client = jsonrpc_client
self.not_found_address = NULL_ADDRESS
self.proxy = proxy
def __init__(self,
jsonrpc_client,
manager_address,
startgas,
gasprice,
poll_timeout=DEFAULT_POLL_TIMEOUT):
# pylint: disable=too-many-arguments
if not isaddress(manager_address):
raise ValueError('manager_address must be a valid address')
check_address_has_code(jsonrpc_client, manager_address,
'Channel Manager')
proxy = jsonrpc_client.new_contract_proxy(
CONTRACT_MANAGER.get_abi(CONTRACT_CHANNEL_MANAGER),
address_encoder(manager_address),
)
self.address = manager_address
self.proxy = proxy
self.client = jsonrpc_client
self.startgas = startgas
self.gasprice = gasprice
self.poll_timeout = poll_timeout
def __init__(
self,
jsonrpc_client,
secret_registry_address,
):
if not is_binary_address(secret_registry_address):
raise InvalidAddress('Expected binary address format for secret registry')
check_address_has_code(jsonrpc_client, secret_registry_address, CONTRACT_SECRET_REGISTRY)
proxy = jsonrpc_client.new_contract_proxy(
CONTRACT_MANAGER.get_contract_abi(CONTRACT_SECRET_REGISTRY),
to_normalized_address(secret_registry_address),
)
if not compare_versions(
proxy.contract.functions.contract_version().call(),
EXPECTED_CONTRACTS_VERSION,
):
raise ContractVersionMismatch('Incompatible ABI for SecretRegistry')
self.address = secret_registry_address
self.proxy = proxy
self.client = jsonrpc_client
self.node_address = privatekey_to_address(self.client.privkey)
self.open_secret_transactions = dict()
def __init__(
self,
jsonrpc_client,
manager_address,
):
if not is_binary_address(manager_address):
raise InvalidAddress('Expected binary address format for token nework')
check_address_has_code(jsonrpc_client, manager_address, CONTRACT_TOKEN_NETWORK)
proxy = jsonrpc_client.new_contract_proxy(
CONTRACT_MANAGER.get_contract_abi(CONTRACT_TOKEN_NETWORK),
to_normalized_address(manager_address),
)
is_good_version = compare_versions(
proxy.contract.functions.contract_version().call(),
EXPECTED_CONTRACTS_VERSION,
)
if not is_good_version:
raise ContractVersionMismatch('Incompatible ABI for TokenNetwork')
self.address = manager_address
self.proxy = proxy
self.client = jsonrpc_client
self.node_address = privatekey_to_address(self.client.privkey)
self.open_channel_transactions = dict()
# Forbids concurrent operations on the same channel
self.channel_operations_lock = defaultdict(RLock)
# Serializes concurent deposits on this token network. This must be an
# exclusive lock, since we need to coordinate the approve and
# setTotalDeposit calls.
self.deposit_lock = Semaphore()
def __init__(
self,
jsonrpc_client,
manager_address,
poll_timeout=DEFAULT_POLL_TIMEOUT,
):
# pylint: disable=too-many-arguments
if not is_binary_address(manager_address):
raise InvalidAddress(
'Expected binary address format for token nework')
check_address_has_code(jsonrpc_client, manager_address,
'Channel Manager')
proxy = jsonrpc_client.new_contract_proxy(
CONTRACT_MANAGER.get_contract_abi(CONTRACT_TOKEN_NETWORK),
to_normalized_address(manager_address),
)
# TODO: add this back
# CONTRACT_MANAGER.check_contract_version(
# proxy.functions.contract_version().call(),
# CONTRACT_TOKEN_NETWORK
# )
self.address = manager_address
self.proxy = proxy
self.client = jsonrpc_client
self.node_address = privatekey_to_address(self.client.privkey)
self.poll_timeout = poll_timeout
# Prevents concurrent deposit, withdraw, close, or settle operations on the same channel
self.channel_operations_lock = dict()
self.open_channel_transactions = dict()
def __init__(self, jsonrpc_client, registry_address: PaymentNetworkID,
contract_manager: ContractManager):
if not is_binary_address(registry_address):
raise InvalidAddress(
"Expected binary address format for token network registry")
check_address_has_code(
client=jsonrpc_client,
address=Address(registry_address),
contract_name=CONTRACT_TOKEN_NETWORK_REGISTRY,
)
self.contract_manager = contract_manager
proxy = jsonrpc_client.new_contract_proxy(
self.contract_manager.get_contract_abi(
CONTRACT_TOKEN_NETWORK_REGISTRY),
to_normalized_address(registry_address),
)
compare_contract_versions(
proxy=proxy,
expected_version=contract_manager.contracts_version,
contract_name=CONTRACT_TOKEN_NETWORK_REGISTRY,
address=Address(registry_address),
)
self.address = registry_address
self.proxy = proxy
self.client = jsonrpc_client
self.node_address = self.client.address
def __init__(
self,
jsonrpc_client,
discovery_address,
):
contract = jsonrpc_client.new_contract(
CONTRACT_MANAGER.get_contract_abi(CONTRACT_ENDPOINT_REGISTRY),
to_normalized_address(discovery_address),
)
proxy = ContractProxy(jsonrpc_client, contract)
if not is_binary_address(discovery_address):
raise ValueError('discovery_address must be a valid address')
check_address_has_code(jsonrpc_client, discovery_address, 'Discovery')
try:
is_valid_version = compare_versions(
proxy.contract.functions.contract_version().call(),
EXPECTED_CONTRACTS_VERSION,
)
if not is_valid_version:
raise ContractVersionMismatch('Incompatible ABI for Discovery')
except BadFunctionCallOutput:
raise AddressWrongContract('')
self.address = discovery_address
self.client = jsonrpc_client
self.not_found_address = NULL_ADDRESS
self.proxy = proxy
def __init__(
self,
jsonrpc_client,
secret_registry_address,
contract_manager: ContractManager,
):
if not is_binary_address(secret_registry_address):
raise InvalidAddress('Expected binary address format for secret registry')
self.contract_manager = contract_manager
check_address_has_code(jsonrpc_client, secret_registry_address, CONTRACT_SECRET_REGISTRY)
proxy = jsonrpc_client.new_contract_proxy(
self.contract_manager.get_contract_abi(CONTRACT_SECRET_REGISTRY),
to_normalized_address(secret_registry_address),
)
compare_contract_versions(
proxy=proxy,
expected_version=contract_manager.contracts_version,
contract_name=CONTRACT_SECRET_REGISTRY,
address=secret_registry_address,
)
self.address = secret_registry_address
self.proxy = proxy
self.client = jsonrpc_client
self.node_address = privatekey_to_address(self.client.privkey)
self.open_secret_transactions = dict()
def __init__(
self,
jsonrpc_client: JSONRPCClient,
token_address: TokenAddress,
contract_manager: ContractManager,
) -> None:
contract = jsonrpc_client.new_contract(
contract_manager.get_contract_abi(CONTRACT_CUSTOM_TOKEN),
Address(token_address))
proxy = ContractProxy(jsonrpc_client, contract)
if not is_binary_address(token_address):
raise ValueError("token_address must be a valid address")
check_address_has_code(jsonrpc_client,
Address(token_address),
"Token",
expected_code=None)
self.address = token_address
self.client = jsonrpc_client
self.node_address = jsonrpc_client.address
self.proxy = proxy
self.token_lock: RLock = RLock()
def __init__(
self,
jsonrpc_client,
secret_registry_address,
poll_timeout=DEFAULT_POLL_TIMEOUT,
):
# pylint: disable=too-many-arguments
if not is_binary_address(secret_registry_address):
raise InvalidAddress(
'Expected binary address format for secret registry')
check_address_has_code(jsonrpc_client, secret_registry_address,
'Registry')
proxy = jsonrpc_client.new_contract_proxy(
CONTRACT_MANAGER.get_contract_abi(CONTRACT_SECRET_REGISTRY),
to_normalized_address(secret_registry_address),
)
# TODO: add this back
# CONTRACT_MANAGER.check_contract_version(
# proxy.functions.contract_version().call(),
# CONTRACT_SECRET_REGISTRY
# )
self.address = secret_registry_address
self.proxy = proxy
self.client = jsonrpc_client
self.poll_timeout = poll_timeout
self.node_address = privatekey_to_address(self.client.privkey)
def tokennetwork_by_token(self, token_address: typing.TokenAddress):
""" Find the token network for `token_address` and return a proxy to
interact with it.
If the token is not already registered it raises `EthNodeCommunicationError`,
since we try to instantiate a Token Network with an empty address.
"""
if not is_binary_address(token_address):
raise InvalidAddress('Expected binary address format for token')
if token_address not in self.token_to_tokennetwork:
check_address_has_code(
self.client, token_address) # check that the token exists
token_network_address = self.get_token_network(token_address)
if token_network_address is None:
raise NoTokenManager(
'TokenNetwork for token 0x{} does not exist'.format(
hexlify(token_address)), )
token_network = TokenNetwork(
self.client,
token_network_address,
self.poll_timeout,
)
self.token_to_tokennetwork[token_address] = token_network
self.address_to_tokennetwork[token_network_address] = token_network
return self.token_to_tokennetwork[token_address]
def __init__(
self,
jsonrpc_client,
manager_address,
poll_timeout=DEFAULT_POLL_TIMEOUT,
):
# pylint: disable=too-many-arguments
contract = jsonrpc_client.new_contract(
CONTRACT_MANAGER.get_contract_abi(CONTRACT_CHANNEL_MANAGER),
to_normalized_address(manager_address),
)
self.proxy = ContractProxy(jsonrpc_client, contract)
if not is_binary_address(manager_address):
raise ValueError('manager_address must be a valid address')
check_address_has_code(jsonrpc_client, manager_address,
'Channel Manager')
CONTRACT_MANAGER.check_contract_version(
self.version(),
CONTRACT_CHANNEL_MANAGER,
)
self.address = manager_address
self.client = jsonrpc_client
self.poll_timeout = poll_timeout
self.open_channel_transactions = dict()
def __init__(
self,
jsonrpc_client,
registry_address: PaymentNetworkID,
contract_manager: ContractManager,
):
if not is_binary_address(registry_address):
raise InvalidAddress('Expected binary address format for token network registry')
check_address_has_code(
client=jsonrpc_client,
address=Address(registry_address),
contract_name=CONTRACT_TOKEN_NETWORK_REGISTRY,
)
self.contract_manager = contract_manager
proxy = jsonrpc_client.new_contract_proxy(
self.contract_manager.get_contract_abi(CONTRACT_TOKEN_NETWORK_REGISTRY),
to_normalized_address(registry_address),
)
compare_contract_versions(
proxy=proxy,
expected_version=contract_manager.contracts_version,
contract_name=CONTRACT_TOKEN_NETWORK_REGISTRY,
address=Address(registry_address),
)
self.address = registry_address
self.proxy = proxy
self.client = jsonrpc_client
self.node_address = privatekey_to_address(self.client.privkey)
def __init__(
self,
jsonrpc_client,
discovery_address,
startgas,
gasprice,
poll_timeout=DEFAULT_POLL_TIMEOUT):
if not isaddress(discovery_address):
raise ValueError('discovery_address must be a valid address')
check_address_has_code(jsonrpc_client, discovery_address, 'Discovery')
proxy = jsonrpc_client.new_contract_proxy(
CONTRACT_MANAGER.get_abi(CONTRACT_ENDPOINT_REGISTRY),
address_encoder(discovery_address),
)
self.address = discovery_address
self.proxy = proxy
self.client = jsonrpc_client
self.startgas = startgas
self.gasprice = gasprice
self.poll_timeout = poll_timeout
self.not_found_address = '0x' + '0' * 40
def __init__(self,
jsonrpc_client,
registry_address,
startgas,
gasprice,
poll_timeout=DEFAULT_POLL_TIMEOUT):
# pylint: disable=too-many-arguments
if not isaddress(registry_address):
raise ValueError('registry_address must be a valid address')
check_address_has_code(jsonrpc_client, registry_address)
proxy = jsonrpc_client.new_contract_proxy(
CONTRACT_MANAGER.get_abi(CONTRACT_REGISTRY),
address_encoder(registry_address),
)
self.address = registry_address
self.proxy = proxy
self.client = jsonrpc_client
self.startgas = startgas
self.gasprice = gasprice
self.poll_timeout = poll_timeout
self.address_to_channelmanager = dict()
self.token_to_channelmanager = dict()
def __init__(
self,
jsonrpc_client: JSONRPCClient,
user_deposit_address: Address,
contract_manager: ContractManager,
proxy_manager: "ProxyManager",
) -> None:
if not is_binary_address(user_deposit_address):
raise ValueError("Expected binary address format for token nework")
check_address_has_code(
client=jsonrpc_client,
address=Address(user_deposit_address),
contract_name=CONTRACT_USER_DEPOSIT,
expected_code=decode_hex(
contract_manager.get_runtime_hexcode(CONTRACT_USER_DEPOSIT)),
)
self.client = jsonrpc_client
self.address = user_deposit_address
self.node_address = self.client.address
self.contract_manager = contract_manager
self.gas_measurements = gas_measurements(
self.contract_manager.contracts_version)
self.proxy_manager = proxy_manager
self.proxy = jsonrpc_client.new_contract_proxy(
abi=self.contract_manager.get_contract_abi(CONTRACT_USER_DEPOSIT),
contract_address=user_deposit_address,
)
self.deposit_lock = RLock()
def __init__(
self,
jsonrpc_client: JSONRPCClient,
monitoring_service_address: MonitoringServiceAddress,
contract_manager: ContractManager,
):
if not is_binary_address(monitoring_service_address):
raise ValueError("Expected binary address for monitoring service")
self.contract_manager = contract_manager
check_address_has_code(
client=jsonrpc_client,
address=Address(monitoring_service_address),
contract_name=CONTRACT_MONITORING_SERVICE,
expected_code=decode_hex(
contract_manager.get_runtime_hexcode(CONTRACT_MONITORING_SERVICE)
),
)
proxy = jsonrpc_client.new_contract_proxy(
abi=self.contract_manager.get_contract_abi(CONTRACT_MONITORING_SERVICE),
contract_address=Address(monitoring_service_address),
)
self.address = monitoring_service_address
self.proxy = proxy
self.client = jsonrpc_client
self.node_address = self.client.address
def manager_by_token(self, token_address):
""" Find the channel manager for `token_address` and return a proxy to
interact with it.
If the token is not already registered it raises `EthNodeCommunicationError`,
since we try to instantiate a Channel manager with an empty address.
"""
if not isaddress(token_address):
raise ValueError('token_address must be a valid address')
if token_address not in self.token_to_channelmanager:
check_address_has_code(self.client, token_address) # check that the token exists
manager_address = self.manager_address_by_token(token_address)
if manager_address is None:
raise NoTokenManager(
'Manager for token 0x{} does not exist'.format(hexlify(token_address))
)
manager = ChannelManager(
self.client,
manager_address,
self.startgas,
self.gasprice,
self.poll_timeout,
)
self.token_to_channelmanager[token_address] = manager
self.address_to_channelmanager[manager_address] = manager
return self.token_to_channelmanager[token_address]
def __init__(
self,
jsonrpc_client,
registry_address,
):
if not is_binary_address(registry_address):
raise InvalidAddress(
'Expected binary address format for token network registry')
check_address_has_code(jsonrpc_client, registry_address,
CONTRACT_TOKEN_NETWORK_REGISTRY)
proxy = jsonrpc_client.new_contract_proxy(
CONTRACT_MANAGER.get_contract_abi(CONTRACT_TOKEN_NETWORK_REGISTRY),
to_normalized_address(registry_address),
)
is_valid_version = compare_versions(
proxy.contract.functions.contract_version().call(),
EXPECTED_CONTRACTS_VERSION,
)
if not is_valid_version:
raise ContractVersionMismatch(
'Incompatible ABI for TokenNetworkRegistry')
self.address = registry_address
self.proxy = proxy
self.client = jsonrpc_client
self.node_address = privatekey_to_address(self.client.privkey)
def __init__(self, jsonrpc_client, secret_registry_address,
contract_manager: ContractManager):
if not is_binary_address(secret_registry_address):
raise InvalidAddress(
"Expected binary address format for secret registry")
self.contract_manager = contract_manager
check_address_has_code(jsonrpc_client, secret_registry_address,
CONTRACT_SECRET_REGISTRY)
proxy = jsonrpc_client.new_contract_proxy(
self.contract_manager.get_contract_abi(CONTRACT_SECRET_REGISTRY),
to_normalized_address(secret_registry_address),
)
# There should be only one smart contract deployed, to avoid race
# conditions for on-chain unlocks.
compare_contract_versions(
proxy=proxy,
expected_version=contract_manager.contracts_version,
contract_name=CONTRACT_SECRET_REGISTRY,
address=secret_registry_address,
)
self.address = secret_registry_address
self.proxy = proxy
self.client = jsonrpc_client
self.node_address = self.client.address
# The dictionary of open transactions is used to avoid sending a
# transaction for the same secret more than once. This requires
# synchronization for the local threads.
self.open_secret_transactions: Dict[Secret, AsyncResult] = dict()
self._open_secret_transactions_lock = Semaphore()
def __init__(
self,
jsonrpc_client: JSONRPCClient,
user_deposit_address: Address,
contract_manager: ContractManager,
):
if not is_binary_address(user_deposit_address):
raise InvalidAddress(
"Expected binary address format for token nework")
check_address_has_code(jsonrpc_client, Address(user_deposit_address),
CONTRACT_USER_DEPOSIT)
self.client = jsonrpc_client
self.address = user_deposit_address
self.node_address = self.client.address
self.contract_manager = contract_manager
self.proxy = jsonrpc_client.new_contract_proxy(
self.contract_manager.get_contract_abi(CONTRACT_USER_DEPOSIT),
to_normalized_address(user_deposit_address),
)
self.deposit_lock = RLock()
def __init__(
self,
jsonrpc_client,
manager_address,
):
if not is_binary_address(manager_address):
raise InvalidAddress(
'Expected binary address format for token nework')
check_address_has_code(jsonrpc_client, manager_address,
'Channel Manager')
proxy = jsonrpc_client.new_contract_proxy(
CONTRACT_MANAGER.get_contract_abi(CONTRACT_TOKEN_NETWORK),
to_normalized_address(manager_address),
)
if not compare_versions(
proxy.contract.functions.contract_version().call(),
EXPECTED_CONTRACTS_VERSION,
):
raise ContractVersionMismatch('Incompatible ABI for TokenNetwork')
self.address = manager_address
self.proxy = proxy
self.client = jsonrpc_client
self.node_address = privatekey_to_address(self.client.privkey)
# Prevents concurrent deposit, withdraw, close, or settle operations on the same channel
self.channel_operations_lock = dict()
self.open_channel_transactions = dict()
def __init__(
self,
rpc_client: JSONRPCClient,
metadata: SmartContractMetadata,
proxy_manager: "ProxyManager",
) -> None:
check_address_has_code(
client=rpc_client,
address=Address(metadata.address),
contract_name=CONTRACT_TOKEN_NETWORK_REGISTRY,
expected_code=metadata.runtime_bytecode,
)
proxy = rpc_client.new_contract_proxy(abi=metadata.abi,
contract_address=Address(
metadata.address))
self.address = TokenNetworkRegistryAddress(metadata.address)
self.proxy_manager = proxy_manager
self.rpc_client = rpc_client
self.gas_measurements = metadata.gas_measurements
self.metadata = metadata
self.node_address = self.rpc_client.address
self.proxy = proxy
def __init__(
self,
jsonrpc_client,
registry_address,
poll_timeout=DEFAULT_POLL_TIMEOUT,
):
# pylint: disable=too-many-arguments
contract = jsonrpc_client.new_contract(
CONTRACT_MANAGER.get_contract_abi(CONTRACT_REGISTRY),
to_normalized_address(registry_address),
)
self.proxy = ContractProxy(jsonrpc_client, contract)
if not is_binary_address(registry_address):
raise ValueError('registry_address must be a valid address')
check_address_has_code(jsonrpc_client, registry_address, 'Registry')
CONTRACT_MANAGER.check_contract_version(
self.proxy.contract.functions.contract_version().call(),
CONTRACT_REGISTRY,
)
self.address = registry_address
self.client = jsonrpc_client
self.poll_timeout = poll_timeout
self.node_address = privatekey_to_address(self.client.privkey)
self.address_to_channelmanager = dict()
self.token_to_channelmanager = dict()
def __init__(
self,
jsonrpc_client: JSONRPCClient,
service_registry_address: Address,
contract_manager: ContractManager,
):
if not is_binary_address(service_registry_address):
raise InvalidAddress(
'Expected binary address for service registry')
self.contract_manager = contract_manager
check_address_has_code(jsonrpc_client, service_registry_address,
CONTRACT_SERVICE_REGISTRY)
proxy = jsonrpc_client.new_contract_proxy(
self.contract_manager.get_contract_abi(CONTRACT_SERVICE_REGISTRY),
to_normalized_address(service_registry_address),
)
compare_contract_versions(
proxy=proxy,
expected_version=contract_manager.contracts_version,
contract_name=CONTRACT_SERVICE_REGISTRY,
address=service_registry_address,
)
self.address = service_registry_address
self.proxy = proxy
self.client = jsonrpc_client
self.node_address = self.client.address
def manager_by_token(self, token_address):
""" Find the channel manager for `token_address` and return a proxy to
interact with it.
If the token is not already registered it raises `EthNodeCommunicationError`,
since we try to instantiate a Channel manager with an empty address.
"""
if not isaddress(token_address):
raise ValueError('token_address must be a valid address')
if token_address not in self.token_to_channelmanager:
check_address_has_code(
self.client, token_address) # check that the token exists
manager_address = self.manager_address_by_token(token_address)
if manager_address is None:
raise NoTokenManager(
'Manager for token 0x{} does not exist'.format(
hexlify(token_address)))
manager = ChannelManager(
self.client,
manager_address,
self.poll_timeout,
)
self.token_to_channelmanager[token_address] = manager
self.address_to_channelmanager[manager_address] = manager
return self.token_to_channelmanager[token_address]
def test_parity_request_pruned_data_raises_an_exception(
deploy_client: JSONRPCClient) -> None:
""" Interacting with an old block identifier with a pruning client throws. """
contract_proxy, _ = deploy_rpc_test_contract(deploy_client,
"RpcWithStorageTest")
iterations = 1000
def send_transaction() -> TransactionMined:
estimated_transaction = deploy_client.estimate_gas(
contract_proxy, "waste_storage", {}, iterations)
assert estimated_transaction
transaction = deploy_client.transact(estimated_transaction)
return deploy_client.poll_transaction(transaction)
first_receipt = send_transaction().receipt
pruned_block_number = first_receipt["blockNumber"]
for _ in range(10):
send_transaction()
with pytest.raises(ValueError):
contract_proxy.functions.const().call(
block_identifier=pruned_block_number)
with pytest.raises(ValueError):
contract_proxy.functions.get(1).call(
block_identifier=pruned_block_number)
with pytest.raises(ValueError):
check_address_has_code(
deploy_client,
to_canonical_address(contract_proxy.address),
"RpcWithStorageTest",
given_block_identifier=pruned_block_number,
)
def __init__(
self,
jsonrpc_client,
discovery_address,
contract_manager: ContractManager,
):
contract = jsonrpc_client.new_contract(
contract_manager.get_contract_abi(CONTRACT_ENDPOINT_REGISTRY),
to_normalized_address(discovery_address),
)
proxy = ContractProxy(jsonrpc_client, contract)
if not is_binary_address(discovery_address):
raise ValueError('discovery_address must be a valid address')
check_address_has_code(jsonrpc_client, discovery_address, 'Discovery')
compare_contract_versions(
proxy=proxy,
expected_version=contract_manager.contracts_version,
contract_name=CONTRACT_ENDPOINT_REGISTRY,
address=discovery_address,
)
self.address = discovery_address
self.node_address = privatekey_to_address(jsonrpc_client.privkey)
self.client = jsonrpc_client
self.not_found_address = NULL_ADDRESS
self.proxy = proxy
def __init__(
self,
jsonrpc_client,
registry_address,
startgas,
gasprice,
poll_timeout=DEFAULT_POLL_TIMEOUT):
# pylint: disable=too-many-arguments
if not isaddress(registry_address):
raise ValueError('registry_address must be a valid address')
check_address_has_code(jsonrpc_client, registry_address, 'Registry')
proxy = jsonrpc_client.new_contract_proxy(
CONTRACT_MANAGER.get_abi(CONTRACT_REGISTRY),
address_encoder(registry_address),
)
self.address = registry_address
self.proxy = proxy
self.client = jsonrpc_client
self.startgas = startgas
self.gasprice = gasprice
self.poll_timeout = poll_timeout
self.address_to_channelmanager = dict()
self.token_to_channelmanager = dict()
def __init__(
self,
jsonrpc_client,
manager_address,
):
if not is_binary_address(manager_address):
raise InvalidAddress('Expected binary address format for token nework')
check_address_has_code(jsonrpc_client, manager_address, CONTRACT_TOKEN_NETWORK)
proxy = jsonrpc_client.new_contract_proxy(
CONTRACT_MANAGER.get_contract_abi(CONTRACT_TOKEN_NETWORK),
to_normalized_address(manager_address),
)
is_good_version = compare_versions(
proxy.contract.functions.contract_version().call(),
EXPECTED_CONTRACTS_VERSION,
)
if not is_good_version:
raise ContractVersionMismatch('Incompatible ABI for TokenNetwork')
self.address = manager_address
self.proxy = proxy
self.client = jsonrpc_client
self.node_address = privatekey_to_address(self.client.privkey)
self.open_channel_transactions = dict()
# Forbids concurrent operations on the same channel
self.channel_operations_lock = defaultdict(RLock)
# Serializes concurent deposits on this token network. This must be an
# exclusive lock, since we need to coordinate the approve and
# setTotalDeposit calls.
self.deposit_lock = Semaphore()
def __init__(
self,
jsonrpc_client,
discovery_address,
):
contract = jsonrpc_client.new_contract(
CONTRACT_MANAGER.get_contract_abi(CONTRACT_ENDPOINT_REGISTRY),
to_normalized_address(discovery_address),
)
proxy = ContractProxy(jsonrpc_client, contract)
if not is_binary_address(discovery_address):
raise ValueError('discovery_address must be a valid address')
check_address_has_code(jsonrpc_client, discovery_address, 'Discovery')
is_valid_version = compare_versions(
proxy.contract.functions.contract_version().call(),
EXPECTED_CONTRACTS_VERSION,
)
if not is_valid_version:
raise ContractVersionMismatch('Incompatible ABI for Discovery')
self.address = discovery_address
self.client = jsonrpc_client
self.not_found_address = NULL_ADDRESS
self.proxy = proxy
def __init__(
self,
jsonrpc_client,
discovery_address,
poll_timeout=DEFAULT_POLL_TIMEOUT,
):
contract = jsonrpc_client.new_contract(
CONTRACT_MANAGER.get_contract_abi(CONTRACT_ENDPOINT_REGISTRY),
to_normalized_address(discovery_address),
)
self.proxy = ContractProxy(jsonrpc_client, contract)
if not is_binary_address(discovery_address):
raise ValueError('discovery_address must be a valid address')
check_address_has_code(jsonrpc_client, discovery_address, 'Discovery')
CONTRACT_MANAGER.check_contract_version(
self.version(),
CONTRACT_ENDPOINT_REGISTRY,
)
self.address = discovery_address
self.client = jsonrpc_client
self.poll_timeout = poll_timeout
self.not_found_address = NULL_ADDRESS
def get_or_deploy_token(runner) -> Tuple[ContractProxy, int]:
""" Deploy or reuse """
token_contract = runner.contract_manager.get_contract(CONTRACT_CUSTOM_TOKEN)
token_config = runner.scenario.get('token', {})
if not token_config:
token_config = {}
address = token_config.get('address')
block = token_config.get('block', 0)
reuse = token_config.get('reuse', False)
token_address_file = runner.data_path.joinpath('token.infos')
if reuse:
if address:
raise ScenarioError('Token settings "address" and "reuse" are mutually exclusive.')
if token_address_file.exists():
token_data = json.loads(token_address_file.read_text())
address = token_data['address']
block = token_data['block']
if address:
check_address_has_code(runner.client, address, 'Token')
token_ctr = runner.client.new_contract_proxy(token_contract['abi'], address)
log.debug(
"Reusing token",
address=to_checksum_address(address),
name=token_ctr.contract.functions.name().call(),
symbol=token_ctr.contract.functions.symbol().call(),
)
return token_ctr, block
token_id = uuid.uuid4()
now = datetime.now()
name = token_config.get('name', f"Scenario Test Token {token_id!s} {now:%Y-%m-%dT%H:%M}")
symbol = token_config.get('symbol', f"T{token_id!s:.3}")
decimals = token_config.get('decimals', 0)
log.debug("Deploying token", name=name, symbol=symbol, decimals=decimals)
token_ctr, receipt = runner.client.deploy_solidity_contract(
'CustomToken',
runner.contract_manager.contracts,
constructor_parameters=(0, decimals, name, symbol),
)
contract_deployment_block = receipt['blockNumber']
contract_checksum_address = to_checksum_address(token_ctr.contract_address)
if reuse:
token_address_file.write_text(json.dumps({
'address': contract_checksum_address,
'block': contract_deployment_block,
}))
log.info(
"Deployed token",
address=contract_checksum_address,
name=name,
symbol=symbol,
)
return token_ctr, contract_deployment_block
def init(
self,
monitoring_service_address: MonitoringServiceAddress,
one_to_n_address: OneToNAddress,
given_block_identifier: BlockSpecification,
) -> None:
""" Initialize the UserDeposit contract with MS and OneToN addresses """
log_details = {
"monitoring_service_address":
to_checksum_address(monitoring_service_address),
"one_to_n_address":
to_checksum_address(one_to_n_address),
}
check_address_has_code(
client=self.client,
address=Address(monitoring_service_address),
contract_name=CONTRACT_MONITORING_SERVICE,
expected_code=decode_hex(
self.contract_manager.get_runtime_hexcode(
CONTRACT_MONITORING_SERVICE)),
)
check_address_has_code(
client=self.client,
address=Address(one_to_n_address),
contract_name=CONTRACT_ONE_TO_N,
expected_code=decode_hex(
self.contract_manager.get_runtime_hexcode(CONTRACT_ONE_TO_N)),
)
try:
existing_monitoring_service_address = self.monitoring_service_address(
block_identifier=given_block_identifier)
existing_one_to_n_address = self.one_to_n_address(
block_identifier=given_block_identifier)
except ValueError:
pass
except BadFunctionCallOutput:
raise_on_call_returned_empty(given_block_identifier)
else:
if existing_monitoring_service_address != EMPTY_ADDRESS:
msg = (
f"MonitoringService contract address is already set to "
f"{to_checksum_address(existing_monitoring_service_address)}"
)
raise BrokenPreconditionError(msg)
if existing_one_to_n_address != EMPTY_ADDRESS:
msg = (f"OneToN contract address is already set to "
f"{to_checksum_address(existing_one_to_n_address)}")
raise BrokenPreconditionError(msg)
with log_transaction(log, "init", log_details):
self._init(
monitoring_service_address=monitoring_service_address,
one_to_n_address=one_to_n_address,
log_details=log_details,
)
def get_or_deploy_token(runner: 'ScenarioRunner') -> ContractProxy:
""" Deploy or reuse """
contract_manager = ContractManager(CONTRACTS_PRECOMPILED_PATH)
token_contract = contract_manager.get_contract(CONTRACT_CUSTOM_TOKEN)
token_config = runner.scenario.get('token', {})
if not token_config:
token_config = {}
address = token_config.get('address')
reuse = token_config.get('reuse', False)
token_address_file = runner.data_path.joinpath('token.addr')
if reuse:
if address:
raise ScenarioError(
'Token settings "address" and "reuse" are mutually exclusive.')
if token_address_file.exists():
address = token_address_file.read_text()
if address:
check_address_has_code(runner.client, address, 'Token')
token_ctr = runner.client.new_contract_proxy(token_contract['abi'],
address)
log.debug(
"Reusing token",
address=to_checksum_address(address),
name=token_ctr.contract.functions.name().call(),
symbol=token_ctr.contract.functions.symbol().call(),
)
return token_ctr
token_id = uuid.uuid4()
now = datetime.now()
name = token_config.get(
'name', f"Scenario Test Token {token_id!s} {now:%Y-%m-%dT%H:%M}")
symbol = token_config.get('symbol', f"T{token_id!s:.3}")
decimals = token_config.get('decimals', 0)
log.debug("Deploying token", name=name, symbol=symbol, decimals=decimals)
token_ctr = runner.client.deploy_solidity_contract(
'CustomToken',
contract_manager.contracts,
constructor_parameters=(0, decimals, name, symbol),
confirmations=1,
)
contract_checksum_address = to_checksum_address(token_ctr.contract_address)
if reuse:
token_address_file.write_text(contract_checksum_address)
log.info(
"Deployed token",
address=contract_checksum_address,
name=name,
symbol=symbol,
)
return token_ctr
def get_or_deploy_token(runner) -> ContractProxy:
""" Deploy or reuse """
contract_manager = ContractManager(contracts_precompiled_path())
token_contract = contract_manager.get_contract(CONTRACT_CUSTOM_TOKEN)
token_config = runner.scenario.get('token', {})
if not token_config:
token_config = {}
address = token_config.get('address')
reuse = token_config.get('reuse', False)
token_address_file = runner.data_path.joinpath('token.addr')
if reuse:
if address:
raise ScenarioError('Token settings "address" and "reuse" are mutually exclusive.')
if token_address_file.exists():
address = token_address_file.read_text()
if address:
check_address_has_code(runner.client, address, 'Token')
token_ctr = runner.client.new_contract_proxy(token_contract['abi'], address)
log.debug(
"Reusing token",
address=to_checksum_address(address),
name=token_ctr.contract.functions.name().call(),
symbol=token_ctr.contract.functions.symbol().call(),
)
return token_ctr
token_id = uuid.uuid4()
now = datetime.now()
name = token_config.get('name', f"Scenario Test Token {token_id!s} {now:%Y-%m-%dT%H:%M}")
symbol = token_config.get('symbol', f"T{token_id!s:.3}")
decimals = token_config.get('decimals', 0)
log.debug("Deploying token", name=name, symbol=symbol, decimals=decimals)
token_ctr = runner.client.deploy_solidity_contract(
'CustomToken',
contract_manager.contracts,
constructor_parameters=(0, decimals, name, symbol),
)
contract_checksum_address = to_checksum_address(token_ctr.contract_address)
if reuse:
token_address_file.write_text(contract_checksum_address)
log.info(
"Deployed token",
address=contract_checksum_address,
name=name,
symbol=symbol,
)
return token_ctr
def manager_address_by_token(self, token_address):
""" Return the channel manager address for the given token or None if
there is no correspoding address.
"""
address = self.proxy.call(
'channelManagerByToken',
token_address,
startgas=self.startgas,
)
if address == b'':
check_address_has_code(self.client, self.address)
return None
return address_decoder(address)
def __init__(
self,
jsonrpc_client,
token_address,
):
contract = jsonrpc_client.new_contract(
CONTRACT_MANAGER.get_contract_abi(CONTRACT_HUMAN_STANDARD_TOKEN),
to_normalized_address(token_address),
)
proxy = ContractProxy(jsonrpc_client, contract)
if not is_binary_address(token_address):
raise ValueError('token_address must be a valid address')
check_address_has_code(jsonrpc_client, token_address, 'Token')
self.address = token_address
self.client = jsonrpc_client
self.proxy = proxy
def __init__(
self,
jsonrpc_client,
token_address,
startgas,
gasprice,
poll_timeout=DEFAULT_POLL_TIMEOUT):
if not isaddress(token_address):
raise ValueError('token_address must be a valid address')
check_address_has_code(jsonrpc_client, token_address, 'Token')
proxy = jsonrpc_client.new_contract_proxy(
CONTRACT_MANAGER.get_abi(CONTRACT_HUMAN_STANDARD_TOKEN),
address_encoder(token_address),
)
self.address = token_address
self.proxy = proxy
self.client = jsonrpc_client
self.startgas = startgas
self.gasprice = gasprice
self.poll_timeout = poll_timeout