def wait_both_channel_deposit(
app_deposit,
app_partner,
registry_address,
token_address,
total_deposit,
retry_timeout,
):
waiting.wait_for_participant_newbalance(
app_deposit.raiden,
registry_address,
token_address,
app_partner.raiden.address,
app_deposit.raiden.address,
total_deposit,
retry_timeout,
)
waiting.wait_for_participant_newbalance(
app_partner.raiden,
registry_address,
token_address,
app_deposit.raiden.address,
app_deposit.raiden.address,
total_deposit,
retry_timeout,
)
def wait_both_channel_deposit(
app_deposit,
app_partner,
registry_address,
token_address,
total_deposit,
retry_timeout,
):
waiting.wait_for_participant_newbalance(
app_deposit.raiden,
registry_address,
token_address,
app_partner.raiden.address,
app_deposit.raiden.address,
total_deposit,
retry_timeout,
)
waiting.wait_for_participant_newbalance(
app_partner.raiden,
registry_address,
token_address,
app_deposit.raiden.address,
app_deposit.raiden.address,
total_deposit,
retry_timeout,
)
def wait_for_usable_channel(
app0,
app1,
registry_address,
token_address,
our_deposit,
partner_deposit,
events_poll_timeout=0.5,
):
""" Wait until the channel from app0 to app1 is usable.
The channel and the deposits are registered, and the partner network state
is reachable.
"""
waiting.wait_for_newchannel(
app0.raiden,
registry_address,
token_address,
app1.raiden.address,
events_poll_timeout,
)
waiting.wait_for_participant_newbalance(
app0.raiden,
registry_address,
token_address,
app1.raiden.address,
app0.raiden.address,
our_deposit,
events_poll_timeout,
)
waiting.wait_for_participant_newbalance(
app0.raiden,
registry_address,
token_address,
app1.raiden.address,
app1.raiden.address,
partner_deposit,
events_poll_timeout,
)
waiting.wait_for_healthy(
app0.raiden,
app1.raiden.address,
events_poll_timeout,
)
def wait_for_usable_channel(
app0,
app1,
registry_address,
token_address,
our_deposit,
partner_deposit,
retry_timeout=DEFAULT_RETRY_TIMEOUT,
):
""" Wait until the channel from app0 to app1 is usable.
The channel and the deposits are registered, and the partner network state
is reachable.
"""
waiting.wait_for_newchannel(
app0.raiden,
registry_address,
token_address,
app1.raiden.address,
retry_timeout,
)
waiting.wait_for_participant_newbalance(
app0.raiden,
registry_address,
token_address,
app1.raiden.address,
app0.raiden.address,
our_deposit,
retry_timeout,
)
waiting.wait_for_participant_newbalance(
app0.raiden,
registry_address,
token_address,
app1.raiden.address,
app1.raiden.address,
partner_deposit,
retry_timeout,
)
waiting.wait_for_healthy(
app0.raiden,
app1.raiden.address,
retry_timeout,
)
def set_total_channel_deposit(
self,
registry_address: typing.PaymentNetworkID,
token_address: typing.TokenAddress,
partner_address: typing.Address,
total_deposit: typing.TokenAmount,
retry_timeout: typing.NetworkTimeout = DEFAULT_RETRY_TIMEOUT,
):
""" Set the `total_deposit` in the channel with the peer at `partner_address` and the
given `token_address` in order to be able to do transfers.
Raises:
InvalidAddress: If either token_address or partner_address is not
20 bytes long.
TransactionThrew: May happen for multiple reasons:
- If the token approval fails, e.g. the token may validate if
account has enough balance for the allowance.
- The deposit failed, e.g. the allowance did not set the token
aside for use and the user spent it before deposit was called.
- The channel was closed/settled between the allowance call and
the deposit call.
AddressWithoutCode: The channel was settled during the deposit
execution.
DepositOverLimit: The total deposit amount is higher than the limit.
"""
chain_state = views.state_from_raiden(self.raiden)
token_networks = views.get_token_network_addresses_for(
chain_state,
registry_address,
)
channel_state = views.get_channelstate_for(
chain_state,
registry_address,
token_address,
partner_address,
)
if not is_binary_address(token_address):
raise InvalidAddress(
'Expected binary address format for token in channel deposit')
if not is_binary_address(partner_address):
raise InvalidAddress(
'Expected binary address format for partner in channel deposit'
)
if token_address not in token_networks:
raise UnknownTokenAddress('Unknown token address')
if channel_state is None:
raise InvalidAddress(
'No channel with partner_address for the given token')
token = self.raiden.chain.token(token_address)
netcontract_address = channel_state.identifier
token_network_registry = self.raiden.chain.token_network_registry(
registry_address)
token_network_address = token_network_registry.get_token_network(
token_address)
token_network_proxy = self.raiden.chain.token_network(
token_network_address)
channel_proxy = self.raiden.chain.payment_channel(
token_network_proxy.address,
netcontract_address,
)
balance = token.balance_of(self.raiden.address)
if self.raiden.config['network_type'] == NetworkType.MAIN:
deposit_limit = (token_network_proxy.proxy.contract.functions.
channel_participant_deposit_limit().call())
if total_deposit > deposit_limit:
raise DepositOverLimit(
'The deposit of {} is bigger than the current limit of {}'.
format(
total_deposit,
deposit_limit,
), )
if total_deposit <= channel_state.our_state.contract_balance:
# no action required
return
addendum = total_deposit - channel_state.our_state.contract_balance
# If this check succeeds it does not imply the the `deposit` will
# succeed, since the `deposit` transaction may race with another
# transaction.
if not balance >= addendum:
msg = 'Not enough balance to deposit. {} Available={} Needed={}'.format(
pex(token_address),
balance,
addendum,
)
raise InsufficientFunds(msg)
# If concurrent operations are happening on the channel, fail the request
with channel_proxy.lock_or_raise():
# set_total_deposit calls approve
# token.approve(netcontract_address, addendum)
channel_proxy.set_total_deposit(total_deposit)
target_address = self.raiden.address
waiting.wait_for_participant_newbalance(
self.raiden,
registry_address,
token_address,
partner_address,
target_address,
total_deposit,
retry_timeout,
)
def set_total_channel_deposit(
self,
registry_address,
token_address,
partner_address,
total_deposit,
poll_timeout=DEFAULT_POLL_TIMEOUT,
retry_timeout=DEFAULT_RETRY_TIMEOUT,
):
""" Set the `total_deposit` in the channel with the peer at `partner_address` and the
given `token_address` in order to be able to do transfers.
Raises:
InvalidAddress: If either token_address or partner_address is not
20 bytes long.
TransactionThrew: May happen for multiple reasons:
- If the token approval fails, e.g. the token may validate if
account has enough balance for the allowance.
- The deposit failed, e.g. the allowance did not set the token
aside for use and the user spent it before deposit was called.
- The channel was closed/settled between the allowance call and
the deposit call.
AddressWithoutCode: The channel was settled during the deposit
execution.
"""
node_state = views.state_from_raiden(self.raiden)
token_networks = views.get_token_network_addresses_for(
node_state,
registry_address,
)
channel_state = views.get_channelstate_for(
node_state,
registry_address,
token_address,
partner_address,
)
if not is_binary_address(token_address):
raise InvalidAddress('Expected binary address format for token in channel deposit')
if not is_binary_address(partner_address):
raise InvalidAddress('Expected binary address format for partner in channel deposit')
if token_address not in token_networks:
raise UnknownTokenAddress('Unknown token address')
if channel_state is None:
raise InvalidAddress('No channel with partner_address for the given token')
token = self.raiden.chain.token(token_address)
balance = token.balance_of(self.raiden.address)
if total_deposit <= channel_state.our_state.contract_balance:
# no action required
return
addendum = total_deposit - channel_state.our_state.contract_balance
# If this check succeeds it does not imply the the `deposit` will
# succeed, since the `deposit` transaction may race with another
# transaction.
if not balance >= addendum:
msg = 'Not enough balance to deposit. {} Available={} Needed={}'.format(
pex(token_address),
balance,
addendum,
)
raise InsufficientFunds(msg)
netcontract_address = channel_state.identifier
channel_proxy = self.raiden.chain.netting_channel(netcontract_address)
# If concurrent operations are happening on the channel, fail the request
if not channel_proxy.channel_operations_lock.acquire(blocking=False):
raise ChannelBusyError(
f'Channel with id {channel_state.identifier} is '
f'busy with another ongoing operation',
)
with releasing(channel_proxy.channel_operations_lock):
token.approve(netcontract_address, addendum)
channel_proxy.set_total_deposit(total_deposit)
msg = 'After {} seconds the deposit was not properly processed.'.format(
poll_timeout,
)
# Wait until the `ChannelNewBalance` event is processed.
with gevent.Timeout(poll_timeout, EthNodeCommunicationError(msg)):
target_address = self.raiden.address
waiting.wait_for_participant_newbalance(
self.raiden,
registry_address,
token_address,
partner_address,
target_address,
total_deposit,
retry_timeout,
)
def set_total_channel_deposit(
self,
registry_address: typing.PaymentNetworkID,
token_address: typing.TokenAddress,
partner_address: typing.Address,
total_deposit: typing.TokenAmount,
retry_timeout: typing.NetworkTimeout = DEFAULT_RETRY_TIMEOUT,
):
""" Set the `total_deposit` in the channel with the peer at `partner_address` and the
given `token_address` in order to be able to do transfers.
Raises:
InvalidAddress: If either token_address or partner_address is not
20 bytes long.
TransactionThrew: May happen for multiple reasons:
- If the token approval fails, e.g. the token may validate if
account has enough balance for the allowance.
- The deposit failed, e.g. the allowance did not set the token
aside for use and the user spent it before deposit was called.
- The channel was closed/settled between the allowance call and
the deposit call.
AddressWithoutCode: The channel was settled during the deposit
execution.
DepositOverLimit: The total deposit amount is higher than the limit.
"""
chain_state = views.state_from_raiden(self.raiden)
token_networks = views.get_token_network_addresses_for(
chain_state,
registry_address,
)
channel_state = views.get_channelstate_for(
chain_state=chain_state,
payment_network_id=registry_address,
token_address=token_address,
partner_address=partner_address,
)
if not is_binary_address(token_address):
raise InvalidAddress('Expected binary address format for token in channel deposit')
if not is_binary_address(partner_address):
raise InvalidAddress('Expected binary address format for partner in channel deposit')
if token_address not in token_networks:
raise UnknownTokenAddress('Unknown token address')
if channel_state is None:
raise InvalidAddress('No channel with partner_address for the given token')
token = self.raiden.chain.token(token_address)
token_network_registry = self.raiden.chain.token_network_registry(registry_address)
token_network_address = token_network_registry.get_token_network(token_address)
token_network_proxy = self.raiden.chain.token_network(token_network_address)
channel_proxy = self.raiden.chain.payment_channel(
token_network_address=token_network_proxy.address,
channel_id=channel_state.identifier,
)
balance = token.balance_of(self.raiden.address)
if self.raiden.config['environment_type'] == Environment.PRODUCTION:
deposit_limit = (
token_network_proxy.proxy.contract.functions.
channel_participant_deposit_limit().call()
)
elif self.raiden.config['environment_type'] == Environment.DEVELOPMENT:
deposit_limit = (
token_network_proxy.proxy.contract.functions.
deposit_limit().call()
)
if total_deposit > deposit_limit:
raise DepositOverLimit(
'The deposit of {} is bigger than the current limit of {}'.format(
total_deposit,
deposit_limit,
),
)
addendum = total_deposit - channel_state.our_state.contract_balance
# If this check succeeds it does not imply the the `deposit` will
# succeed, since the `deposit` transaction may race with another
# transaction.
if not balance >= addendum:
msg = 'Not enough balance to deposit. {} Available={} Needed={}'.format(
pex(token_address),
balance,
addendum,
)
raise InsufficientFunds(msg)
# set_total_deposit calls approve
# token.approve(netcontract_address, addendum)
channel_proxy.set_total_deposit(total_deposit)
target_address = self.raiden.address
waiting.wait_for_participant_newbalance(
raiden=self.raiden,
payment_network_id=registry_address,
token_address=token_address,
partner_address=partner_address,
target_address=target_address,
target_balance=total_deposit,
retry_timeout=retry_timeout,
)
def set_total_channel_deposit(
self,
registry_address: typing.PaymentNetworkID,
token_address: typing.TokenAddress,
partner_address: typing.Address,
total_deposit: typing.TokenAmount,
retry_timeout: typing.NetworkTimeout = DEFAULT_RETRY_TIMEOUT,
):
""" Set the `total_deposit` in the channel with the peer at `partner_address` and the
given `token_address` in order to be able to do transfers.
Raises:
InvalidAddress: If either token_address or partner_address is not
20 bytes long.
TransactionThrew: May happen for multiple reasons:
- If the token approval fails, e.g. the token may validate if
account has enough balance for the allowance.
- The deposit failed, e.g. the allowance did not set the token
aside for use and the user spent it before deposit was called.
- The channel was closed/settled between the allowance call and
the deposit call.
AddressWithoutCode: The channel was settled during the deposit
execution.
DepositOverLimit: The total deposit amount is higher than the limit.
"""
chain_state = views.state_from_raiden(self.raiden)
token_addresses = views.get_token_identifiers(
chain_state,
registry_address,
)
channel_state = views.get_channelstate_for(
chain_state=chain_state,
payment_network_id=registry_address,
token_address=token_address,
partner_address=partner_address,
)
if not is_binary_address(token_address):
raise InvalidAddress(
'Expected binary address format for token in channel deposit')
if not is_binary_address(partner_address):
raise InvalidAddress(
'Expected binary address format for partner in channel deposit'
)
if token_address not in token_addresses:
raise UnknownTokenAddress('Unknown token address')
if channel_state is None:
raise InvalidAddress(
'No channel with partner_address for the given token')
if self.raiden.config['environment_type'] == Environment.PRODUCTION:
per_token_network_deposit_limit = RED_EYES_PER_TOKEN_NETWORK_LIMIT
else:
per_token_network_deposit_limit = UINT256_MAX
token = self.raiden.chain.token(token_address)
token_network_registry = self.raiden.chain.token_network_registry(
registry_address)
token_network_address = token_network_registry.get_token_network(
token_address)
token_network_proxy = self.raiden.chain.token_network(
token_network_address)
channel_proxy = self.raiden.chain.payment_channel(
canonical_identifier=channel_state.canonical_identifier, )
if total_deposit == 0:
raise DepositMismatch(
'Attempted to deposit with total deposit being 0')
addendum = total_deposit - channel_state.our_state.contract_balance
total_network_balance = token.balance_of(registry_address)
if total_network_balance + addendum > per_token_network_deposit_limit:
raise DepositOverLimit(
f'The deposit of {addendum} will exceed the '
f'token network limit of {per_token_network_deposit_limit}', )
balance = token.balance_of(self.raiden.address)
functions = token_network_proxy.proxy.contract.functions
deposit_limit = functions.channel_participant_deposit_limit().call()
if total_deposit > deposit_limit:
raise DepositOverLimit(
f'The additional deposit of {addendum} will exceed the '
f'channel participant limit of {deposit_limit}', )
# If this check succeeds it does not imply the the `deposit` will
# succeed, since the `deposit` transaction may race with another
# transaction.
if not balance >= addendum:
msg = 'Not enough balance to deposit. {} Available={} Needed={}'.format(
pex(token_address),
balance,
addendum,
)
raise InsufficientFunds(msg)
# set_total_deposit calls approve
# token.approve(netcontract_address, addendum)
channel_proxy.set_total_deposit(
total_deposit=total_deposit,
block_identifier=views.state_from_raiden(self.raiden).block_hash,
)
target_address = self.raiden.address
waiting.wait_for_participant_newbalance(
raiden=self.raiden,
payment_network_id=registry_address,
token_address=token_address,
partner_address=partner_address,
target_address=target_address,
target_balance=total_deposit,
retry_timeout=retry_timeout,
)
def set_total_channel_deposit(
self,
registry_address,
token_address,
partner_address,
total_deposit,
poll_timeout=DEFAULT_POLL_TIMEOUT,
retry_timeout=DEFAULT_RETRY_TIMEOUT,
):
""" Set the `total_deposit` in the channel with the peer at `partner_address` and the
given `token_address` in order to be able to do transfers.
Raises:
InvalidAddress: If either token_address or partner_address is not
20 bytes long.
TransactionThrew: May happen for multiple reasons:
- If the token approval fails, e.g. the token may validate if
account has enough balance for the allowance.
- The deposit failed, e.g. the allowance did not set the token
aside for use and the user spent it before deposit was called.
- The channel was closed/settled between the allowance call and
the deposit call.
AddressWithoutCode: The channel was settled during the deposit
execution.
DepositOverLimit: The total deposit amount is higher than the limit.
"""
chain_state = views.state_from_raiden(self.raiden)
token_networks = views.get_token_network_addresses_for(
chain_state,
registry_address,
)
channel_state = views.get_channelstate_for(
chain_state,
registry_address,
token_address,
partner_address,
)
if not is_binary_address(token_address):
raise InvalidAddress('Expected binary address format for token in channel deposit')
if not is_binary_address(partner_address):
raise InvalidAddress('Expected binary address format for partner in channel deposit')
if token_address not in token_networks:
raise UnknownTokenAddress('Unknown token address')
if channel_state is None:
raise InvalidAddress('No channel with partner_address for the given token')
token = self.raiden.chain.token(token_address)
netcontract_address = channel_state.identifier
token_network_registry = self.raiden.chain.token_network_registry(registry_address)
token_network_address = token_network_registry.get_token_network(token_address)
token_network_proxy = self.raiden.chain.token_network(token_network_address)
channel_proxy = self.raiden.chain.payment_channel(
token_network_proxy.address,
netcontract_address,
)
balance = token.balance_of(self.raiden.address)
deposit_limit = token_network_proxy.proxy.contract.functions.deposit_limit().call()
if total_deposit > deposit_limit:
raise DepositOverLimit(
'The deposit of {} is bigger than the current limit of {}'.format(
total_deposit,
deposit_limit,
),
)
if total_deposit <= channel_state.our_state.contract_balance:
# no action required
return
addendum = total_deposit - channel_state.our_state.contract_balance
# If this check succeeds it does not imply the the `deposit` will
# succeed, since the `deposit` transaction may race with another
# transaction.
if not balance >= addendum:
msg = 'Not enough balance to deposit. {} Available={} Needed={}'.format(
pex(token_address),
balance,
addendum,
)
raise InsufficientFunds(msg)
# If concurrent operations are happening on the channel, fail the request
with channel_proxy.lock_or_raise():
# set_total_deposit calls approve
# token.approve(netcontract_address, addendum)
channel_proxy.set_total_deposit(total_deposit)
msg = 'After {} seconds the deposit was not properly processed.'.format(
poll_timeout,
)
# Wait until the `ChannelNewBalance` event is processed.
with gevent.Timeout(poll_timeout, EthNodeCommunicationError(msg)):
target_address = self.raiden.address
waiting.wait_for_participant_newbalance(
self.raiden,
registry_address,
token_address,
partner_address,
target_address,
total_deposit,
retry_timeout,
)
