def get_channel_list(
self,
registry_address: typing.PaymentNetworkID,
token_address: typing.TokenAddress = None,
partner_address: typing.Address = None,
) -> typing.List[NettingChannelState]:
"""Returns a list of channels associated with the optionally given
`token_address` and/or `partner_address`.
Args:
token_address: an optionally provided token address
partner_address: an optionally provided partner address
Return:
A list containing all channels the node participates. Optionally
filtered by a token address and/or partner address.
Raises:
KeyError: An error occurred when the token address is unknown to the node.
"""
if registry_address and not is_binary_address(registry_address):
raise InvalidAddress('Expected binary address format for registry in get_channel_list')
if token_address and not is_binary_address(token_address):
raise InvalidAddress('Expected binary address format for token in get_channel_list')
if partner_address:
if not is_binary_address(partner_address):
raise InvalidAddress(
'Expected binary address format for partner in get_channel_list',
)
if not token_address:
raise UnknownTokenAddress('Provided a partner address but no token address')
if token_address and partner_address:
channel_state = views.get_channelstate_for(
chain_state=views.state_from_raiden(self.raiden),
payment_network_id=registry_address,
token_address=token_address,
partner_address=partner_address,
)
if channel_state:
result = [channel_state]
else:
result = []
elif token_address:
result = views.list_channelstate_for_tokennetwork(
chain_state=views.state_from_raiden(self.raiden),
payment_network_id=registry_address,
token_address=token_address,
)
else:
result = views.list_all_channelstate(
chain_state=views.state_from_raiden(self.raiden),
)
return result
def make_graph(
edge_list: List[Tuple[typing.Address, typing.Address]],
) -> networkx.Graph:
""" Returns a graph that represents the connections among the netting
contracts.
Args:
edge_list: All the channels that compose the graph.
Returns:
A graph where the nodes are nodes in the network and the edges are
nodes that have a channel between them.
"""
for edge in edge_list:
if len(edge) != 2:
raise ValueError('All values in edge_list must be of length two (origin, destination)')
origin, destination = edge
if not is_binary_address(origin) or not is_binary_address(destination):
raise ValueError('All values in edge_list must be valid addresses')
graph = networkx.Graph() # undirected graph, for bidirectional channels
for first, second in edge_list:
graph.add_edge(first, second)
return graph
def token_network_leave(
self,
registry_address: typing.PaymentNetworkID,
token_address: typing.TokenAddress,
) -> typing.List[NettingChannelState]:
""" Close all channels and wait for settlement. """
if not is_binary_address(registry_address):
raise InvalidAddress('registry_address must be a valid address in binary')
if not is_binary_address(token_address):
raise InvalidAddress('token_address must be a valid address in binary')
if token_address not in self.get_tokens_list(registry_address):
raise UnknownTokenAddress('token_address unknown')
token_network_identifier = views.get_token_network_identifier_by_token_address(
chain_state=views.state_from_raiden(self.raiden),
payment_network_id=registry_address,
token_address=token_address,
)
connection_manager = self.raiden.connection_manager_for_token_network(
token_network_identifier,
)
return connection_manager.leave(registry_address)
def get_channel_list(self, registry_address, token_address=None, partner_address=None):
"""Returns a list of channels associated with the optionally given
`token_address` and/or `partner_address`.
Args:
token_address (bin): an optionally provided token address
partner_address (bin): an optionally provided partner address
Return:
A list containing all channels the node participates. Optionally
filtered by a token address and/or partner address.
Raises:
KeyError: An error occurred when the token address is unknown to the node.
"""
if token_address and not is_binary_address(token_address):
raise InvalidAddress('Expected binary address format for token in get_channel_list')
if partner_address and not is_binary_address(partner_address):
raise InvalidAddress('Expected binary address format for partner in get_channel_list')
result = list()
if token_address and partner_address:
channel_state = views.get_channelstate_for(
views.state_from_raiden(self.raiden),
registry_address,
token_address,
partner_address,
)
if channel_state:
result = [channel_state]
else:
result = []
elif token_address:
result = views.list_channelstate_for_tokennetwork(
views.state_from_raiden(self.raiden),
registry_address,
token_address,
)
elif partner_address:
result = views.list_channelstate_for_tokennetwork(
views.state_from_raiden(self.raiden),
registry_address,
partner_address,
)
else:
result = views.list_all_channelstate(
views.state_from_raiden(self.raiden),
)
return result
def transfer_async(
self,
registry_address: typing.PaymentNetworkID,
token_address: typing.TokenAddress,
amount: typing.TokenAmount,
target: typing.Address,
identifier: typing.PaymentID = None,
):
if not isinstance(amount, int):
raise InvalidAmount('Amount not a number')
if amount <= 0:
raise InvalidAmount('Amount negative')
if not is_binary_address(token_address):
raise InvalidAddress('token address is not valid.')
if not is_binary_address(target):
raise InvalidAddress('target address is not valid.')
valid_tokens = views.get_token_network_addresses_for(
views.state_from_raiden(self.raiden),
registry_address,
)
if token_address not in valid_tokens:
raise UnknownTokenAddress('Token address is not known.')
log.debug(
'Initiating transfer',
initiator=pex(self.raiden.address),
target=pex(target),
token=pex(token_address),
amount=amount,
identifier=identifier,
)
payment_network_identifier = self.raiden.default_registry.address
token_network_identifier = views.get_token_network_identifier_by_token_address(
chain_state=views.state_from_raiden(self.raiden),
payment_network_id=payment_network_identifier,
token_address=token_address,
)
async_result = self.raiden.mediated_transfer_async(
token_network_identifier=token_network_identifier,
amount=amount,
target=target,
identifier=identifier,
)
return async_result
def token_network_connect(
self,
registry_address: typing.PaymentNetworkID,
token_address: typing.TokenAddress,
funds: typing.TokenAmount,
initial_channel_target: int = 3,
joinable_funds_target: float = 0.4,
) -> None:
""" Automatically maintain channels open for the given token network.
Args:
token_address: the ERC20 token network to connect to.
funds: the amount of funds that can be used by the ConnectionMananger.
initial_channel_target: number of channels to open proactively.
joinable_funds_target: fraction of the funds that will be used to join
channels opened by other participants.
"""
if not is_binary_address(registry_address):
raise InvalidAddress('registry_address must be a valid address in binary')
if not is_binary_address(token_address):
raise InvalidAddress('token_address must be a valid address in binary')
token_network_identifier = views.get_token_network_identifier_by_token_address(
chain_state=views.state_from_raiden(self.raiden),
payment_network_id=registry_address,
token_address=token_address,
)
connection_manager = self.raiden.connection_manager_for_token_network(
token_network_identifier,
)
has_enough_reserve, estimated_required_reserve = has_enough_gas_reserve(
raiden=self.raiden,
channels_to_open=initial_channel_target,
)
if not has_enough_reserve:
raise InsufficientGasReserve((
'The account balance is below the estimated amount necessary to '
'finish the lifecycles of all active channels. A balance of at '
f'least {estimated_required_reserve} wei is required.'
))
connection_manager.connect(
funds=funds,
initial_channel_target=initial_channel_target,
joinable_funds_target=joinable_funds_target,
)
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 get_blockchain_events_channel(
self,
token_address: typing.TokenAddress,
partner_address: typing.Address = None,
from_block: typing.BlockSpecification = GENESIS_BLOCK_NUMBER,
to_block: typing.BlockSpecification = 'latest',
):
if not is_binary_address(token_address):
raise InvalidAddress(
'Expected binary address format for token in get_blockchain_events_channel',
)
token_network_address = self.raiden.default_registry.get_token_network(
token_address,
)
if token_network_address is None:
raise UnknownTokenAddress('Token address is not known.')
channel_list = self.get_channel_list(
registry_address=self.raiden.default_registry.address,
token_address=token_address,
partner_address=partner_address,
)
returned_events = []
for channel in channel_list:
returned_events.extend(blockchain_events.get_all_netting_channel_events(
chain=self.raiden.chain,
token_network_address=token_network_address,
netting_channel_identifier=channel.identifier,
contract_manager=self.raiden.contract_manager,
from_block=from_block,
to_block=to_block,
))
returned_events.sort(key=lambda evt: evt.get('block_number'), reverse=True)
return returned_events
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 token_network_connect(
self,
registry_address,
token_address,
funds,
initial_channel_target=3,
joinable_funds_target=.4,
):
"""Automatically maintain channels open for the given token network.
Args:
token_address (bin): the ERC20 token network to connect to.
funds (int): the amount of funds that can be used by the ConnectionMananger.
initial_channel_target (int): number of channels to open proactively.
joinable_funds_target (float): fraction of the funds that will be used to join
channels opened by other participants.
"""
if not is_binary_address(token_address):
raise InvalidAddress('token_address must be a valid address in binary')
token_network_identifier = views.get_token_network_identifier_by_token_address(
views.state_from_raiden(self.raiden),
payment_network_id=registry_address,
token_address=token_address,
)
connection_manager = self.raiden.connection_manager_for_token_network(
token_network_identifier,
)
connection_manager.connect(
funds,
initial_channel_target=initial_channel_target,
joinable_funds_target=joinable_funds_target,
)
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 validate_address(value):
"""
Helper function for validating an address
"""
if is_bytes(value):
if not is_binary_address(value):
raise InvalidAddress("Address must be 20 bytes when input type is bytes", value)
return
if not isinstance(value, str):
raise TypeError('Address {} must be provided as a string'.format(value))
if not is_hex_address(value):
raise InvalidAddress("Address must be 20 bytes, as a hex string with a 0x prefix", value)
if not is_checksum_address(value):
if value == value.lower():
raise InvalidAddress(
"Web3.py only accepts checksum addresses. "
"The software that gave you this non-checksum address should be considered unsafe, "
"please file it as a bug on their platform. "
"Try using an ENS name instead. Or, if you must accept lower safety, "
"use Web3.toChecksumAddress(lower_case_address).",
value,
)
else:
raise InvalidAddress(
"Address has an invalid EIP-55 checksum. "
"After looking up the address from the original source, try again.",
value,
)
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 send_async(
self,
receiver_address: Address,
queue_name: bytes,
message: Message,
):
if not self._running:
return
self.log.info(
'SEND ASYNC',
receiver_address=to_normalized_address(receiver_address),
message=message,
queue_name=queue_name,
)
if not is_binary_address(receiver_address):
raise ValueError('Invalid address {}'.format(pex(receiver_address)))
# These are not protocol messages, but transport specific messages
if isinstance(message, (Delivered, Ping, Pong)):
raise ValueError(
'Do not use send_async for {} messages'.format(message.__class__.__name__),
)
message_id = message.message_identifier
async_result = AsyncResult()
if isinstance(message, Processed):
async_result.set(True) # processed messages shouldn't get a Delivered reply
self._send_immediate(receiver_address, json.dumps(message.to_dict()))
else:
self._messageids_to_asyncresult[message_id] = async_result
self._send_with_retry(receiver_address, async_result, json.dumps(message.to_dict()))
def setup_address(self, name, address=default, transact={}):
'''
Set up the name to point to the supplied address.
The sender of the transaction must own the name, or
its parent name.
Example: If the caller owns ``parentname.eth`` with no subdomains
and calls this method with ``sub.parentname.eth``,
then ``sub`` will be created as part of this call.
:param str name: ENS name to set up, in checksum format
:param str address: name will point to this address. If ``None``, erase the record.
If not specified, name will point to the owner's address.
:param dict transact: the transaction configuration, like in
:meth:`~web3.eth.Eth.sendTransaction`
:raises InvalidName: if ``name`` has invalid syntax
:raises UnauthorizedError: if ``'from'`` in `transact` does not own `name`
'''
owner = self.setup_owner(name, transact=transact)
self._assert_control(owner, name)
if not address or address == EMPTY_ADDR_HEX:
address = None
elif address is default:
address = owner
elif is_binary_address(address):
address = to_checksum_address(address)
elif not is_checksum_address(address):
raise ValueError("You must supply the address in checksum format")
if self.address(name) == address:
return None
if address is None:
address = EMPTY_ADDR_HEX
transact['from'] = owner
resolver = self._set_resolver(name, transact=transact)
return resolver.setAddr(dot_eth_namehash(name), address, transact=transact)
def get_blockchain_events_token_network(
self,
token_address: typing.TokenAddress,
from_block: typing.BlockSpecification = GENESIS_BLOCK_NUMBER,
to_block: typing.BlockSpecification = 'latest',
):
"""Returns a list of blockchain events coresponding to the token_address."""
if not is_binary_address(token_address):
raise InvalidAddress(
'Expected binary address format for token in get_blockchain_events_token_network',
)
token_network_address = self.raiden.default_registry.get_token_network(
token_address,
)
if token_network_address is None:
raise UnknownTokenAddress('Token address is not known.')
returned_events = blockchain_events.get_token_network_events(
chain=self.raiden.chain,
token_network_address=token_network_address,
contract_manager=self.raiden.contract_manager,
events=blockchain_events.ALL_EVENTS,
from_block=from_block,
to_block=to_block,
)
for event in returned_events:
if event.get('args'):
event['args'] = dict(event['args'])
returned_events.sort(key=lambda evt: evt.get('block_number'), reverse=True)
return returned_events
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,
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,
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 token_network_register(
self,
registry_address: typing.PaymentNetworkID,
token_address: typing.TokenAddress,
retry_timeout: typing.NetworkTimeout = DEFAULT_RETRY_TIMEOUT,
) -> typing.TokenNetworkAddress:
"""Register the `token_address` in the blockchain. If the address is already
registered but the event has not been processed this function will block
until the next block to make sure the event is processed.
Raises:
InvalidAddress: If the registry_address or token_address is not a valid address.
AlreadyRegisteredTokenAddress: If the token is already registered.
TransactionThrew: If the register transaction failed, this may
happen because the account has not enough balance to pay for the
gas or this register call raced with another transaction and lost.
"""
if not is_binary_address(registry_address):
raise InvalidAddress('registry_address must be a valid address in binary')
if not is_binary_address(token_address):
raise InvalidAddress('token_address must be a valid address in binary')
if token_address in self.get_tokens_list(registry_address):
raise AlreadyRegisteredTokenAddress('Token already registered')
try:
registry = self.raiden.chain.token_network_registry(registry_address)
return registry.add_token(token_address)
except RaidenRecoverableError as e:
if 'Token already registered' in str(e):
raise AlreadyRegisteredTokenAddress('Token already registered')
# else
raise
finally:
# Assume the transaction failed because the token is already
# registered with the smart contract and this node has not yet
# polled for the event (otherwise the check above would have
# failed).
#
# To provide a consistent view to the user, wait one block, this
# will guarantee that the events have been processed.
next_block = self.raiden.get_block_number() + 1
waiting.wait_for_block(self.raiden, next_block, retry_timeout)
def token_network_register(
self,
registry_address,
token_address,
poll_timeout=DEFAULT_POLL_TIMEOUT,
retry_timeout=DEFAULT_RETRY_TIMEOUT,
) -> typing.TokenNetworkAddress:
"""Register the `token_address` in the blockchain. If the address is already
registered but the event has not been processed this function will block
until the next block to make sure the event is processed.
Raises:
InvalidAddress: If the registry_address or token_address is not a valid address.
AlreadyRegisteredTokenAddress: If the token is already registered.
TransactionThrew: If the register transaction failed, this may
happen because the account has not enough balance to pay for the
gas or this register call raced with another transaction and lost.
"""
if not is_binary_address(registry_address):
raise InvalidAddress('registry_address must be a valid address in binary')
if not is_binary_address(token_address):
raise InvalidAddress('token_address must be a valid address in binary')
if token_address in self.get_tokens_list(registry_address):
raise AlreadyRegisteredTokenAddress('Token already registered')
try:
registry = self.raiden.chain.token_network_registry(registry_address)
msg = 'After {} seconds the channel was not properly created.'.format(
poll_timeout,
)
with gevent.Timeout(poll_timeout, EthNodeCommunicationError(msg)):
return registry.add_token(token_address)
finally:
# Assume the transaction failed because the token is already
# registered with the smart contract and this node has not yet
# polled for the event (otherwise the check above would have
# failed).
#
# To provide a consistent view to the user, wait one block, this
# will guarantee that the events have been processed.
next_block = self.raiden.get_block_number() + 1
waiting.wait_for_block(self.raiden, next_block, retry_timeout)
def channel_batch_close(
self,
registry_address: typing.PaymentNetworkID,
token_address: typing.TokenAddress,
partner_addresses: typing.List[typing.Address],
retry_timeout: typing.NetworkTimeout = DEFAULT_RETRY_TIMEOUT,
):
"""Close a channel opened with `partner_address` for the given
`token_address`.
Race condition, this can fail if channel was closed externally.
"""
if not is_binary_address(token_address):
raise InvalidAddress('Expected binary address format for token in channel close')
if not all(map(is_binary_address, partner_addresses)):
raise InvalidAddress('Expected binary address format for partner in channel close')
valid_tokens = views.get_token_network_addresses_for(
chain_state=views.state_from_raiden(self.raiden),
payment_network_id=registry_address,
)
if token_address not in valid_tokens:
raise UnknownTokenAddress('Token address is not known.')
chain_state = views.state_from_raiden(self.raiden)
channels_to_close = views.filter_channels_by_partneraddress(
chain_state=chain_state,
payment_network_id=registry_address,
token_address=token_address,
partner_addresses=partner_addresses,
)
token_network_identifier = views.get_token_network_identifier_by_token_address(
chain_state=views.state_from_raiden(self.raiden),
payment_network_id=registry_address,
token_address=token_address,
)
for channel_state in channels_to_close:
channel_close = ActionChannelClose(
token_network_identifier=token_network_identifier,
channel_identifier=channel_state.identifier,
)
self.raiden.handle_state_change(channel_close)
channel_ids = [channel_state.identifier for channel_state in channels_to_close]
waiting.wait_for_close(
raiden=self.raiden,
payment_network_id=registry_address,
token_address=token_address,
channel_ids=channel_ids,
retry_timeout=retry_timeout,
)
def get_channel(self, registry_address, token_address, partner_address):
if not is_binary_address(token_address):
raise InvalidAddress('Expected binary address format for token in get_channel')
if not is_binary_address(partner_address):
raise InvalidAddress('Expected binary address format for partner in get_channel')
channel_list = self.get_channel_list(registry_address, token_address, partner_address)
assert len(channel_list) <= 1
if not channel_list:
raise ChannelNotFound(
"Channel with partner '{}' for token '{}' could not be found.".format(
to_checksum_address(partner_address),
to_checksum_address(token_address),
),
)
return channel_list[0]
def maybe_send(self, recipient: typing.Address, message: Message):
""" Send message to recipient if the transport is running. """
if not is_binary_address(recipient):
raise InvalidAddress('Invalid address {}'.format(pex(recipient)))
messagedata = message.encode()
host_port = self.get_host_port(recipient)
self.maybe_sendraw(host_port, messagedata)
def token_network(self, address: Address) -> TokenNetwork:
if not is_binary_address(address):
raise ValueError('address must be a valid address')
if address not in self.address_to_token_network:
self.address_to_token_network[address] = TokenNetwork(
self.client,
address,
)
return self.address_to_token_network[address]
def secret_registry(self, address: Address) -> SecretRegistry:
if not is_binary_address(address):
raise ValueError('address must be a valid address')
if address not in self.address_to_secret_registry:
self.address_to_secret_registry[address] = SecretRegistry(
self.client,
address,
)
return self.address_to_secret_registry[address]
def token_network_registry(self, address: Address) -> TokenNetworkRegistry:
if not is_binary_address(address):
raise ValueError('address must be a valid address')
if address not in self.address_to_token_network_registry:
self.address_to_token_network_registry[
address] = TokenNetworkRegistry(
self.client,
address,
)
return self.address_to_token_network_registry[address]
def discovery(self, discovery_address: Address) -> Discovery:
""" Return a proxy to interact with the discovery. """
if not is_binary_address(discovery_address):
raise ValueError('discovery_address must be a valid address')
if discovery_address not in self.address_to_discovery:
self.address_to_discovery[discovery_address] = Discovery(
self.client,
discovery_address,
)
return self.address_to_discovery[discovery_address]
def channel_batch_close(
self,
registry_address: TokenNetworkRegistryAddress,
token_address: TokenAddress,
partner_addresses: List[Address],
retry_timeout: NetworkTimeout = DEFAULT_RETRY_TIMEOUT,
) -> None:
"""Close a channel opened with `partner_address` for the given
`token_address`.
Race condition, this can fail if channel was closed externally.
"""
if not is_binary_address(token_address):
raise InvalidBinaryAddress("Expected binary address format for token in channel close")
if not all(map(is_binary_address, partner_addresses)):
raise InvalidBinaryAddress(
"Expected binary address format for partner in channel close"
)
valid_tokens = views.get_token_identifiers(
chain_state=views.state_from_raiden(self.raiden),
token_network_registry_address=registry_address,
)
if token_address not in valid_tokens:
raise UnknownTokenAddress("Token address is not known.")
chain_state = views.state_from_raiden(self.raiden)
channels_to_close = views.filter_channels_by_partneraddress(
chain_state=chain_state,
token_network_registry_address=registry_address,
token_address=token_address,
partner_addresses=partner_addresses,
)
close_state_changes: List[StateChange] = [
ActionChannelClose(canonical_identifier=channel_state.canonical_identifier)
for channel_state in channels_to_close
]
greenlets = set(self.raiden.handle_state_changes(close_state_changes))
gevent.joinall(greenlets, raise_error=True)
channel_ids = [channel_state.identifier for channel_state in channels_to_close]
waiting.wait_for_close(
raiden=self.raiden,
token_network_registry_address=registry_address,
token_address=token_address,
channel_ids=channel_ids,
retry_timeout=retry_timeout,
)
def token(self, token_address: Address) -> Token:
""" Return a proxy to interact with a token. """
if not is_binary_address(token_address):
raise ValueError('token_address must be a valid address')
if token_address not in self.address_to_token:
self.address_to_token[token_address] = Token(
self.client,
token_address,
)
return self.address_to_token[token_address]
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,
self.poll_timeout,
)
return self.address_to_registry[registry_address]
def token(self, token_address: Address) -> Token:
""" Return a proxy to interact with a token. """
if not is_binary_address(token_address):
raise ValueError('token_address must be a valid address')
if token_address not in self.address_to_token:
self.address_to_token[token_address] = Token(
self.client,
token_address,
)
return self.address_to_token[token_address]
def token_network(self, address: Address) -> TokenNetwork:
if not is_binary_address(address):
raise ValueError('address must be a valid address')
if address not in self.address_to_token_network:
self.address_to_token_network[address] = TokenNetwork(
self.client,
address,
self.poll_timeout,
)
return self.address_to_token_network[address]
def secret_registry(self, address: Address) -> SecretRegistry:
if not is_binary_address(address):
raise ValueError('address must be a valid address')
if address not in self.address_to_secret_registry:
self.address_to_secret_registry[address] = SecretRegistry(
self.client,
address,
self.poll_timeout,
)
return self.address_to_secret_registry[address]
def token_network(self, address: Address) -> TokenNetwork:
if not is_binary_address(address):
raise ValueError('address must be a valid address')
with self._token_network_creation_lock:
if address not in self.address_to_token_network:
self.address_to_token_network[address] = TokenNetwork(
self.client,
address,
)
return self.address_to_token_network[address]
def discovery(self, discovery_address: Address) -> Discovery:
""" Return a proxy to interact with the discovery. """
if not is_binary_address(discovery_address):
raise ValueError('discovery_address must be a valid address')
if discovery_address not in self.address_to_discovery:
self.address_to_discovery[discovery_address] = Discovery(
self.client,
discovery_address,
)
return self.address_to_discovery[discovery_address]
def secret_registry(self, address: Address) -> SecretRegistry:
if not is_binary_address(address):
raise ValueError('address must be a valid address')
with self._secret_registry_creation_lock:
if address not in self.address_to_secret_registry:
self.address_to_secret_registry[address] = SecretRegistry(
self.client,
address,
)
return self.address_to_secret_registry[address]
def token_network_register(
self,
registry_address,
token_address,
poll_timeout=DEFAULT_POLL_TIMEOUT,
):
"""Register the `token_address` in the blockchain. If the address is already
registered but the event has not been processed this function will block
until the next block to make sure the event is processed.
Raises:
InvalidAddress: If the registry_address or token_address is not a valid address.
AlreadyRegisteredTokenAddress: If the token is already registered.
TransactionThrew: If the register transaction failed, this may
happen because the account has not enough balance to pay for the
gas or this register call raced with another transaction and lost.
"""
if not is_binary_address(registry_address):
raise InvalidAddress('registry_address must be a valid address in binary')
if not is_binary_address(token_address):
raise InvalidAddress('token_address must be a valid address in binary')
if token_address in self.get_tokens_list(registry_address):
raise AlreadyRegisteredTokenAddress('Token already registered')
try:
registry = self.raiden.chain.registry(registry_address)
return registry.add_token(token_address)
finally:
# Assume the transaction failed because the token is already
# registered with the smart contract and this node has not yet
# polled for the event (otherwise the check above would have
# failed).
#
# To provide a consistent view to the user, wait one block, this
# will guarantee that the events have been processed.
next_block = self.raiden.get_block_number() + 1
waiting.wait_for_block(self.raiden, next_block, poll_timeout)
def add_token(self, token_address: typing.TokenAddress):
if not is_binary_address(token_address):
raise InvalidAddress('Expected binary address format for token')
log.info(
'add_token called',
node=pex(self.node_address),
token_address=pex(token_address),
registry_address=pex(self.address),
)
transaction_hash = self.proxy.transact(
'createERC20TokenNetwork',
token_address,
)
self.client.poll(unhexlify(transaction_hash))
receipt_or_none = check_transaction_threw(self.client,
transaction_hash)
if receipt_or_none:
log.info(
'add_token failed',
node=pex(self.node_address),
token_address=pex(token_address),
registry_address=pex(self.address),
)
raise TransactionThrew('createERC20TokenNetwork', receipt_or_none)
token_network_address = self.get_token_network(token_address)
if token_network_address is None:
log.info(
'add_token failed and check_transaction_threw didnt detect it',
node=pex(self.node_address),
token_address=pex(token_address),
registry_address=pex(self.address),
)
raise RuntimeError('token_to_token_networks failed')
self.token_to_tokennetwork[token_address] = TokenNetwork(
self.client,
token_network_address,
)
log.info(
'add_token sucessful',
node=pex(self.node_address),
token_address=pex(token_address),
registry_address=pex(self.address),
token_network_address=pex(token_network_address),
)
return token_network_address
def token_network(self, address: TokenNetworkAddress) -> TokenNetwork:
if not is_binary_address(address):
raise ValueError('address must be a valid address')
with self._token_network_creation_lock:
if address not in self.address_to_token_network:
self.address_to_token_network[address] = TokenNetwork(
jsonrpc_client=self.client,
token_network_address=address,
contract_manager=self.contract_manager,
)
return self.address_to_token_network[address]
def get_raiden_events_payment_history_with_timestamps(
self,
token_address: typing.TokenAddress = None,
target_address: typing.Address = None,
limit: int = None,
offset: int = None,
):
if token_address and not is_binary_address(token_address):
raise InvalidAddress(
'Expected binary address format for token in get_raiden_events_payment_history',
)
if target_address and not is_binary_address(target_address):
raise InvalidAddress(
'Expected binary address format for '
'target_address in get_raiden_events_payment_history',
)
token_network_identifier = None
if token_address:
token_network_identifier = views.get_token_network_identifier_by_token_address(
chain_state=views.state_from_raiden(self.raiden),
payment_network_id=self.raiden.default_registry.address,
token_address=token_address,
)
events = [
event
for event in self.raiden.wal.storage.get_events_with_timestamps(
limit=limit,
offset=offset,
) if event_filter_for_payments(
event=event.wrapped_event,
token_network_identifier=token_network_identifier,
partner_address=target_address,
)
]
return events
def get_channel(self, registry_address, token_address, partner_address):
if not is_binary_address(token_address):
raise InvalidAddress(
'Expected binary address format for token in get_channel')
if not is_binary_address(partner_address):
raise InvalidAddress(
'Expected binary address format for partner in get_channel')
channel_list = self.get_channel_list(registry_address, token_address,
partner_address)
assert len(channel_list) <= 1
if not channel_list:
raise ChannelNotFound(
"Channel with partner '{}' for token '{}' could not be found.".
format(
to_checksum_address(partner_address),
to_checksum_address(token_address),
), )
return channel_list[0]
def user_deposit(self, address: Address) -> UserDeposit:
if not is_binary_address(address):
raise ValueError("address must be a valid address")
with self._user_deposit_creation_lock:
if address not in self.address_to_user_deposit:
self.address_to_user_deposit[address] = UserDeposit(
jsonrpc_client=self.client,
user_deposit_address=address,
contract_manager=self.contract_manager,
)
return self.address_to_user_deposit[address]
def get_raiden_events_payment_history_with_timestamps(
self,
token_address: typing.TokenAddress = None,
target_address: typing.Address = None,
limit: int = None,
offset: int = None,
):
if token_address and not is_binary_address(token_address):
raise InvalidAddress(
'Expected binary address format for token in get_raiden_events_payment_history',
)
if target_address and not is_binary_address(target_address):
raise InvalidAddress(
'Expected binary address format for '
'target_address in get_raiden_events_payment_history',
)
token_network_identifier = None
if token_address:
token_network_identifier = views.get_token_network_identifier_by_token_address(
chain_state=views.state_from_raiden(self.raiden),
payment_network_id=self.raiden.default_registry.address,
token_address=token_address,
)
events = [
event
for event in self.raiden.wal.storage.get_events_with_timestamps(
limit=limit,
offset=offset,
) if event_filter_for_payments(
event=event.wrapped_event,
token_network_identifier=token_network_identifier,
partner_address=target_address,
)
]
return events
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 one_to_n(self, address: OneToNAddress) -> OneToN:
if not is_binary_address(address):
raise ValueError("address must be a valid address")
with self._one_to_n_creation_lock:
if address not in self.address_to_one_to_n:
self.address_to_one_to_n[address] = OneToN(
jsonrpc_client=self.client,
one_to_n_address=address,
contract_manager=self.contract_manager,
)
return self.address_to_one_to_n[address]
def register(self, node_address: bytes, host: str, port: int):
if not is_binary_address(node_address):
raise ValueError('node_address must be a valid address')
try:
socket.inet_pton(socket.AF_INET, host)
except OSError:
raise ValueError('invalid ip address provided: {}'.format(host))
if not isinstance(port, int):
raise ValueError('port must be a valid number')
self.nodeid_to_hostport[node_address] = (host, port)
def register(self, node_address: bytes, host: str, port: int):
if not is_binary_address(node_address):
raise ValueError('node_address must be a valid address')
try:
socket.inet_pton(socket.AF_INET, host)
except OSError:
raise ValueError('invalid ip address provided: {}'.format(host))
if not isinstance(port, int):
raise ValueError('port must be a valid number')
self.nodeid_to_hostport[node_address] = (host, port)
def secret_registry(self, address: Address) -> SecretRegistry:
if not is_binary_address(address):
raise ValueError("address must be a valid address")
with self._secret_registry_creation_lock:
if address not in self.address_to_secret_registry:
self.address_to_secret_registry[address] = SecretRegistry(
jsonrpc_client=self.client,
secret_registry_address=address,
contract_manager=self.contract_manager,
)
return self.address_to_secret_registry[address]
def add_token(self, token_address):
if not is_binary_address(token_address):
raise ValueError('token_address must be a valid address')
log.info(
'add_token called',
node=pex(self.node_address),
token_address=pex(token_address),
registry_address=pex(self.address),
)
transaction_hash = self.proxy.transact(
'addToken',
self.address,
token_address,
)
self.client.poll(unhexlify(transaction_hash),
timeout=self.poll_timeout)
receipt_or_none = check_transaction_threw(self.client,
transaction_hash)
if receipt_or_none:
log.info(
'add_token failed',
node=pex(self.node_address),
token_address=pex(token_address),
registry_address=pex(self.address),
)
raise TransactionThrew('AddToken', receipt_or_none)
manager_address = self.manager_address_by_token(token_address)
if manager_address is None:
log.info(
'add_token failed and check_transaction_threw didnt detect it',
node=pex(self.node_address),
token_address=pex(token_address),
registry_address=pex(self.address),
)
raise RuntimeError('channelManagerByToken failed')
log.info(
'add_token sucessful',
node=pex(self.node_address),
token_address=pex(token_address),
registry_address=pex(self.address),
manager_address=pex(manager_address),
)
return manager_address
def token_network_leave(self, registry_address, token_address, only_receiving=True):
"""Close all channels and wait for settlement."""
if not is_binary_address(token_address):
raise InvalidAddress('token_address must be a valid address in binary')
if token_address not in self.get_tokens_list(registry_address):
raise UnknownTokenAddress('token_address unknown')
connection_manager = self.raiden.connection_manager_for_token(
registry_address,
token_address,
)
return connection_manager.leave(only_receiving)
def discovery(self, discovery_address: Address) -> Discovery:
""" Return a proxy to interact with the discovery. """
if not is_binary_address(discovery_address):
raise ValueError('discovery_address must be a valid address')
with self._discovery_creation_lock:
if discovery_address not in self.address_to_discovery:
self.address_to_discovery[discovery_address] = Discovery(
jsonrpc_client=self.client,
discovery_address=discovery_address,
contract_manager=self.contract_manager,
)
return self.address_to_discovery[discovery_address]
def token_network_leave(
self, registry_address: PaymentNetworkID, token_address: TokenAddress
) -> List[NettingChannelState]:
""" Close all channels and wait for settlement. """
if not is_binary_address(registry_address):
raise InvalidAddress("registry_address must be a valid address in binary")
if not is_binary_address(token_address):
raise InvalidAddress("token_address must be a valid address in binary")
if token_address not in self.get_tokens_list(registry_address):
raise UnknownTokenAddress("token_address unknown")
token_network_identifier = views.get_token_network_identifier_by_token_address(
chain_state=views.state_from_raiden(self.raiden),
payment_network_id=registry_address,
token_address=token_address,
)
connection_manager = self.raiden.connection_manager_for_token_network(
token_network_identifier
)
return connection_manager.leave(registry_address)
def netting_channel(self, netting_channel_address: Address) -> NettingChannel:
""" Return a proxy to interact with a NettingChannelContract. """
if not is_binary_address(netting_channel_address):
raise ValueError('netting_channel_address must be a valid address')
if netting_channel_address not in self.address_to_nettingchannel:
channel = NettingChannel(
self.client,
netting_channel_address,
self.poll_timeout,
)
self.address_to_nettingchannel[netting_channel_address] = channel
return self.address_to_nettingchannel[netting_channel_address]
def get_channel(
self,
registry_address: PaymentNetworkID,
token_address: TokenAddress,
partner_address: Address,
) -> NettingChannelState:
if not is_binary_address(token_address):
raise InvalidAddress("Expected binary address format for token in get_channel")
if not is_binary_address(partner_address):
raise InvalidAddress("Expected binary address format for partner in get_channel")
channel_list = self.get_channel_list(registry_address, token_address, partner_address)
assert len(channel_list) <= 1
if not channel_list:
raise ChannelNotFound(
"Channel with partner '{}' for token '{}' could not be found.".format(
to_checksum_address(partner_address), to_checksum_address(token_address)
)
)
return channel_list[0]
def token(self, token_address: TokenAddress) -> Token:
""" Return a proxy to interact with a token. """
if not is_binary_address(token_address):
raise ValueError("token_address must be a valid address")
with self._token_creation_lock:
if token_address not in self.address_to_token:
self.address_to_token[token_address] = Token(
jsonrpc_client=self.client,
token_address=token_address,
contract_manager=self.contract_manager,
)
return self.address_to_token[token_address]
def get_token_network_events(
self,
token_address: typing.TokenAddress,
from_block: typing.BlockSpecification = 0,
to_block: typing.BlockSpecification = 'latest',
):
if not is_binary_address(token_address):
raise InvalidAddress(
'Expected binary address format for token in get_token_network_events',
)
token_network_address = self.raiden.default_registry.get_token_network(
token_address, )
if token_network_address is None:
raise UnknownTokenAddress('Token address is not known.')
returned_events = get_token_network_events(
self.raiden.chain,
token_network_address,
events=ALL_EVENTS,
from_block=from_block,
to_block=to_block,
)
for event in returned_events:
if event.get('args'):
event['args'] = dict(event['args'])
# the channel_identifier is a hash
encode_byte_values(event['args'])
hexbytes_to_str(event)
raiden_events = self.raiden.wal.storage.get_events_by_block(
from_block=from_block,
to_block=to_block,
)
# Here choose which raiden internal events we want to expose to the end user
for block_number, event in raiden_events:
if isinstance(event, EVENTS_PAYMENT_HISTORY_RELATED):
new_event = {
'block_number': block_number,
'event': type(event).__name__,
}
new_event.update(event.__dict__)
returned_events.append(new_event)
returned_events.sort(key=lambda evt: evt.get('block_number'),
reverse=True)
return returned_events
def token_network_connect(
self,
registry_address: typing.PaymentNetworkID,
token_address: typing.TokenAddress,
funds: typing.TokenAmount,
initial_channel_target: int = 3,
joinable_funds_target: float = 0.4,
) -> None:
""" Automatically maintain channels open for the given token network.
Args:
token_address: the ERC20 token network to connect to.
funds: the amount of funds that can be used by the ConnectionMananger.
initial_channel_target: number of channels to open proactively.
joinable_funds_target: fraction of the funds that will be used to join
channels opened by other participants.
"""
if not is_binary_address(registry_address):
raise InvalidAddress('registry_address must be a valid address in binary')
if not is_binary_address(token_address):
raise InvalidAddress('token_address must be a valid address in binary')
token_network_identifier = views.get_token_network_identifier_by_token_address(
views.state_from_raiden(self.raiden),
payment_network_id=registry_address,
token_address=token_address,
)
connection_manager = self.raiden.connection_manager_for_token_network(
token_network_identifier,
)
connection_manager.connect(
funds,
initial_channel_target=initial_channel_target,
joinable_funds_target=joinable_funds_target,
)
def setup_name(
self,
name: str,
address: Optional[ChecksumAddress] = None,
transact: Optional["TxParams"] = None
) -> HexBytes:
"""
Set up the address for reverse lookup, aka "caller ID".
After successful setup, the method :meth:`~ens.main.ENS.name` will return
`name` when supplied with `address`.
:param str name: ENS name that address will point to
:param str address: to set up, in checksum format
:param dict transact: the transaction configuration, like in
:meth:`~web3.eth.send_transaction`
:raises AddressMismatch: if the name does not already point to the address
:raises InvalidName: if `name` has invalid syntax
:raises UnauthorizedError: if ``'from'`` in `transact` does not own `name`
:raises UnownedName: if no one owns `name`
"""
if not transact:
transact = {}
transact = deepcopy(transact)
if not name:
self._assert_control(address, 'the reverse record')
return self._setup_reverse(None, address, transact=transact)
else:
resolved = self.address(name)
if is_none_or_zero_address(address):
address = resolved
elif resolved and address != resolved and resolved != EMPTY_ADDR_HEX:
raise AddressMismatch(
f"Could not set address {address!r} to point to name, "
f"because the name resolves to {resolved!r}. "
"To change the name for an existing address, call "
"setup_address() first."
)
if is_none_or_zero_address(address):
address = self.owner(name)
if is_none_or_zero_address(address):
raise UnownedName("claim subdomain using setup_address() first")
if is_binary_address(address):
address = to_checksum_address(address)
if not is_checksum_address(address):
raise ValueError("You must supply the address in checksum format")
self._assert_control(address, name)
if not resolved:
self.setup_address(name, address, transact=transact)
return self._setup_reverse(name, address, transact=transact)
def get_channel(self, registry_address, token_address, partner_address):
if not is_binary_address(token_address):
raise InvalidAddress(
'Expected binary address format for token in get_channel')
if not is_binary_address(partner_address):
raise InvalidAddress(
'Expected binary address format for partner in get_channel')
channel_identifer = calculate_channel_identifier(
self.raiden.address, partner_address)
channel_list = self.get_channel_list(registry_address, token_address,
partner_address)
for channel in channel_list:
if channel.identifier == channel_identifer:
return channel
raise ChannelNotFound(
"Channel with partner '{}' for token '{}' could not be found.".
format(
to_checksum_address(partner_address),
to_checksum_address(token_address),
), )
