def test_list_all_channelstate():
test_state = factories.make_chain_state(number_of_channels=3)
assert sorted(channel.partner_state.address
for channel in views.list_all_channelstate(
test_state.chain_state)) == sorted(
channel.partner_state.address
for channel in test_state.channels)
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 get_channel_list(self, 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 isaddress(token_address):
raise InvalidAddress(
'Expected binary address format for token in get_channel_list')
if partner_address and not isaddress(partner_address):
raise InvalidAddress(
'Expected binary address format for partner in get_channel_list'
)
registry_address = self.raiden.default_registry.address
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 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 notice_explorer_to_be_alive(endpoint_explorer, discoverable, node_address, raiden_instance):
"""
Notice api explorer what node is alive, sending a
HTTP request
"""
try:
raiden = raiden_instance
channels = views.list_all_channelstate(chain_state=views.state_from_raiden(raiden))
if discoverable and len(channels) == 0 and endpoint_explorer:
url = endpoint_explorer + "luminoNode/" + node_address
response = requests.get(url)
if response.status_code == 200:
json_data = json.loads(response.text)
data = json_data['data']
data['last_alive_signal'] = datetime.utcnow().isoformat()
headers = {'Content-type': 'application/json', 'Accept': 'application/json'}
response = requests.put(url, json=data, headers=headers)
if response.status_code == 200:
log.info("Succesfully send alive signal to Lumino Explorer")
else:
log.info("Warning: There was an error sending alive signal to Lumino Explorer. Status: " +
str(response.status_code))
else:
log.info("Warning: send alive signal to Lumino Explorer, is not posible because node is not registered")
except requests.exceptions.RequestException as e:
log.info("Warning: Could not connect to Lumino Explorer. Your node will not send alive signal.")
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 install_and_query_all_blockchain_filters(
self,
token_network_registry_address,
secret_registry_address,
from_block=0,
):
token_network_registry = self.chain.token_network_registry(
token_network_registry_address)
secret_registry = self.chain.secret_registry(secret_registry_address)
channels = views.list_all_channelstate(views.state_from_raiden(self), )
token_networks = views.get_token_network_identifiers(
views.state_from_raiden(self),
token_network_registry_address,
)
# Install the filters and then poll them and dispatch the events to the WAL
with self.event_poll_lock:
self.blockchain_events.add_token_network_registry_listener(
token_network_registry,
from_block,
)
self.blockchain_events.add_secret_registry_listener(
secret_registry,
from_block,
)
for token_network in token_networks:
token_network_proxy = self.chain.token_network(token_network)
self.blockchain_events.add_token_network_listener(
token_network_proxy,
from_block,
)
for channel_state in channels:
channel_proxy = self.chain.payment_channel(
channel_state.token_network_identifier,
channel_state.identifier,
)
self.blockchain_events.add_payment_channel_listener(
channel_proxy,
from_block,
)
chain_id = self.chain.network_id
# We need to query the events at this point in order to obtain an up to
# date view of the blockchain right before the node starts its transport
# and starts receiving messages.
for event in self.blockchain_events.poll_blockchain_events(
self.get_block_number(), ):
on_blockchain_event(
self,
event,
event.event_data['block_number'],
chain_id,
)
def get_node_balances(
chain_state,
token_network_address: TokenNetworkAddress) -> List[Tuple[Any]]:
channels = views.list_all_channelstate(chain_state)
channels = [
channel for channel in channels
if channel.canonical_identifier.token_network_address ==
to_canonical_address(token_network_address)
]
balances = [(
channel_state.partner_state.address,
channel.get_balance(channel_state.our_state,
channel_state.partner_state),
channel.get_balance(channel_state.partner_state,
channel_state.our_state),
) for channel_state in channels]
return balances
def install_all_blockchain_filters(
self,
token_network_registry_proxy,
secret_registry_proxy,
from_block,
):
with self.event_poll_lock:
node_state = views.state_from_raiden(self)
channels = views.list_all_channelstate(node_state)
token_networks = views.get_token_network_identifiers(
node_state,
token_network_registry_proxy.address,
)
self.blockchain_events.add_token_network_registry_listener(
token_network_registry_proxy,
from_block,
)
self.blockchain_events.add_secret_registry_listener(
secret_registry_proxy,
from_block,
)
for token_network in token_networks:
token_network_proxy = self.chain.token_network(token_network)
self.blockchain_events.add_token_network_listener(
token_network_proxy,
from_block,
)
for channel_state in channels:
channel_proxy = self.chain.payment_channel(
channel_state.token_network_identifier,
channel_state.identifier,
)
self.blockchain_events.add_payment_channel_listener(
channel_proxy,
from_block,
)
def install_all_blockchain_filters(
self,
token_network_registry_proxy,
secret_registry_proxy,
from_block,
):
with self.event_poll_lock:
node_state = views.state_from_raiden(self)
channels = views.list_all_channelstate(node_state)
token_networks = views.get_token_network_identifiers(
node_state,
token_network_registry_proxy.address,
)
self.blockchain_events.add_token_network_registry_listener(
token_network_registry_proxy,
from_block,
)
self.blockchain_events.add_secret_registry_listener(
secret_registry_proxy,
from_block,
)
for token_network in token_networks:
token_network_proxy = self.chain.token_network(token_network)
self.blockchain_events.add_token_network_listener(
token_network_proxy,
from_block,
)
for channel_state in channels:
channel_proxy = self.chain.payment_channel(
channel_state.token_network_identifier,
channel_state.identifier,
)
self.blockchain_events.add_payment_channel_listener(
channel_proxy,
from_block,
)
