def get_connection_managers_info(self, registry_address):
"""Get a dict whose keys are token addresses and whose values are
open channels, funds of last request, sum of deposits and number of channels"""
connection_managers = dict()
for token in self.raiden_api.get_tokens_list(registry_address):
try:
connection_manager = self.raiden_api.raiden.connection_manager_for_token(
registry_address,
token,
)
except InvalidAddress:
connection_manager = None
open_channels = views.get_channelstate_open(
views.state_from_raiden(self.raiden_api.raiden),
registry_address,
token,
)
if connection_manager is not None and open_channels:
connection_managers[to_checksum_address(
connection_manager.token_address)] = {
'funds':
connection_manager.funds,
'sum_deposits':
views.get_our_capacity_for_token_network(
views.state_from_raiden(self.raiden_api.raiden),
registry_address,
token,
),
'channels':
len(open_channels),
}
return connection_managers
def _funds_remaining(self) -> int:
"""The remaining funds after subtracting the already deposited amounts.
Note:
- This attribute must be accessed with the lock held.
"""
if self.funds > 0:
token = self.raiden.chain.token(self.token_address)
token_balance = token.balance_of(self.raiden.address)
sum_deposits = views.get_our_capacity_for_token_network(
views.state_from_raiden(self.raiden), self.registry_address,
self.token_address)
return min(self.funds - sum_deposits, token_balance)
return 0
def _funds_remaining(self) -> int:
"""The remaining funds after subtracting the already deposited amounts.
Note:
- This attribute must be accessed with the lock held.
"""
if self.funds > 0:
sum_deposits = views.get_our_capacity_for_token_network(
views.state_from_raiden(self.raiden),
self.registry_address,
self.token_address,
)
remaining = self.funds - sum_deposits
return remaining
return 0
def get_connection_managers_info(
self, registry_address: typing.PaymentNetworkID):
"""Get a dict whose keys are token addresses and whose values are
open channels, funds of last request, sum of deposits and number of channels"""
log.debug(
'Getting connection managers info',
node=pex(self.raiden_api.address),
registry_address=to_checksum_address(registry_address),
)
connection_managers = dict()
for token in self.raiden_api.get_tokens_list(registry_address):
token_network_identifier = views.get_token_network_identifier_by_token_address(
views.state_from_raiden(self.raiden_api.raiden),
payment_network_id=registry_address,
token_address=token,
)
try:
connection_manager = self.raiden_api.raiden.connection_manager_for_token_network(
token_network_identifier, )
except InvalidAddress:
connection_manager = None
open_channels = views.get_channelstate_open(
chain_state=views.state_from_raiden(self.raiden_api.raiden),
payment_network_id=registry_address,
token_address=token,
)
if connection_manager is not None and open_channels:
connection_managers[to_checksum_address(
connection_manager.token_address)] = {
'funds':
connection_manager.funds,
'sum_deposits':
views.get_our_capacity_for_token_network(
views.state_from_raiden(self.raiden_api.raiden),
registry_address,
token,
),
'channels':
len(open_channels),
}
return connection_managers
def _funds_remaining(self) -> int:
"""The remaining funds after subtracting the already deposited amounts.
Note:
- This attribute must be accessed with the lock held.
"""
if self.funds > 0:
payment_network_id = self.raiden.default_registry.address
sum_deposits = views.get_our_capacity_for_token_network(
views.state_from_raiden(self.raiden),
payment_network_id,
self.token_address,
)
remaining = self.funds - sum_deposits
return remaining
return 0
def log_open_channels(raiden, registry_address, token_address, funds):
chain_state = views.state_from_raiden(raiden)
open_channels = views.get_channelstate_open(
chain_state=chain_state,
payment_network_id=registry_address,
token_address=token_address)
if open_channels:
sum_deposits = views.get_our_capacity_for_token_network(
views.state_from_raiden(raiden), registry_address, token_address)
log.debug(
"connect() called on an already joined token network",
node=pex(raiden.address),
registry_address=pex(registry_address),
token_address=pex(token_address),
open_channels=len(open_channels),
sum_deposits=sum_deposits,
funds=funds,
)
def log_open_channels(raiden, registry_address, token_address, funds):
open_channels = views.get_channelstate_open(
views.state_from_raiden(raiden),
registry_address,
token_address,
)
if open_channels:
sum_deposits = views.get_our_capacity_for_token_network(
views.state_from_raiden(raiden),
registry_address,
token_address,
)
log.debug(
'connect() called on an already joined token network',
registry_address=pex(registry_address),
token_address=pex(token_address),
open_channels=len(open_channels),
sum_deposits=sum_deposits,
funds=funds,
)
def log_open_channels(raiden, registry_address, token_address, funds):
chain_state = views.state_from_raiden(raiden)
open_channels = views.get_channelstate_open(
chain_state=chain_state,
payment_network_id=registry_address,
token_address=token_address,
)
if open_channels:
sum_deposits = views.get_our_capacity_for_token_network(
views.state_from_raiden(raiden),
registry_address,
token_address,
)
log.debug(
'connect() called on an already joined token network',
registry_address=pex(registry_address),
token_address=pex(token_address),
open_channels=len(open_channels),
sum_deposits=sum_deposits,
funds=funds,
)
def get_connection_managers_info(self, registry_address):
"""Get a dict whose keys are token addresses and whose values are
open channels, funds of last request, sum of deposits and number of channels"""
connection_managers = dict()
for token in self.raiden_api.get_tokens_list(registry_address):
token_network_identifier = views.get_token_network_identifier_by_token_address(
views.state_from_raiden(self.raiden_api.raiden),
payment_network_id=registry_address,
token_address=token,
)
try:
connection_manager = self.raiden_api.raiden.connection_manager_for_token_network(
token_network_identifier,
)
except InvalidAddress:
connection_manager = None
open_channels = views.get_channelstate_open(
chain_state=views.state_from_raiden(self.raiden_api.raiden),
payment_network_id=registry_address,
token_address=token,
)
if connection_manager is not None and open_channels:
connection_managers[to_checksum_address(connection_manager.token_address)] = {
'funds': connection_manager.funds,
'sum_deposits': views.get_our_capacity_for_token_network(
views.state_from_raiden(self.raiden_api.raiden),
registry_address,
token,
),
'channels': len(open_channels),
}
return connection_managers
