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, 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,
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 __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 = jsonrpc_client.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 = self.client.address
self.open_secret_transactions = dict()
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,
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,
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,
token_network_address: typing.TokenNetworkAddress,
contract_manager: ContractManager,
):
if not is_binary_address(token_network_address):
raise InvalidAddress(
'Expected binary address format for token nework')
check_address_has_code(
jsonrpc_client,
typing.Address(token_network_address),
CONTRACT_TOKEN_NETWORK,
)
self.contract_manager = contract_manager
proxy = jsonrpc_client.new_contract_proxy(
self.contract_manager.get_contract_abi(CONTRACT_TOKEN_NETWORK),
to_normalized_address(token_network_address),
)
compare_contract_versions(
proxy=proxy,
expected_version=contract_manager.contracts_version,
contract_name=CONTRACT_TOKEN_NETWORK,
address=typing.Address(token_network_address),
)
self.address = token_network_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()
