def settle(
self,
transferred_amount: int,
locked_amount: int,
locksroot: typing.Locksroot,
partner: typing.Address,
partner_transferred_amount: int,
partner_locked_amount: int,
partner_locksroot: typing.Locksroot,
):
""" Settle the channel.
Raises:
ChannelBusyError: If the channel is busy with another operation
"""
log.info(
'settle called',
token_network=pex(self.address),
node=pex(self.node_address),
partner=pex(partner),
transferred_amount=transferred_amount,
locked_amount=locked_amount,
locksroot=encode_hex(locksroot),
partner_transferred_amount=partner_transferred_amount,
partner_locked_amount=partner_locked_amount,
partner_locksroot=encode_hex(partner_locksroot),
)
self._check_channel_lock(partner)
with releasing(self.channel_operations_lock[partner]):
transaction_hash = self.proxy.transact(
'settleChannel',
self.node_address,
transferred_amount,
locked_amount,
locksroot,
partner,
partner_transferred_amount,
partner_locked_amount,
partner_locksroot,
)
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(
'settle failed',
token_network=pex(self.address),
node=pex(self.node_address),
partner=pex(partner),
transferred_amount=transferred_amount,
locked_amount=locked_amount,
locksroot=encode_hex(locksroot),
partner_transferred_amount=partner_transferred_amount,
partner_locked_amount=partner_locked_amount,
partner_locksroot=encode_hex(partner_locksroot),
)
channel_closed = self.channel_is_closed(partner)
if channel_closed is False:
raise ChannelIncorrectStateError(
'Channel is not in a closed state. It cannot be settled'
)
raise TransactionThrew('Settle', receipt_or_none)
log.info(
'settle successful',
token_network=pex(self.address),
node=pex(self.node_address),
partner=pex(partner),
transferred_amount=transferred_amount,
locked_amount=locked_amount,
locksroot=encode_hex(locksroot),
partner_transferred_amount=partner_transferred_amount,
partner_locked_amount=partner_locked_amount,
partner_locksroot=encode_hex(partner_locksroot),
)
def update_transfer(
self,
partner: typing.Address,
nonce: typing.Nonce,
balance_hash: typing.BalanceHash,
additional_hash: typing.AdditionalHash,
partner_signature: typing.Signature,
signature: typing.Signature,
):
log.info(
'updateNonClosingBalanceProof called',
token_network=pex(self.address),
node=pex(self.node_address),
partner=pex(partner),
nonce=nonce,
balance_hash=encode_hex(balance_hash),
additional_hash=encode_hex(additional_hash),
partner_signature=encode_hex(partner_signature),
signature=encode_hex(signature),
)
transaction_hash = self.proxy.transact(
'updateNonClosingBalanceProof',
partner,
self.node_address,
balance_hash,
nonce,
additional_hash,
partner_signature,
signature,
)
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.critical(
'updateNonClosingBalanceProof failed',
token_network=pex(self.address),
node=pex(self.node_address),
partner=pex(partner),
nonce=nonce,
balance_hash=encode_hex(balance_hash),
additional_hash=encode_hex(additional_hash),
partner_signature=encode_hex(partner_signature),
signature=encode_hex(signature),
)
channel_closed = self.channel_is_closed(partner)
if channel_closed is False:
raise ChannelIncorrectStateError(
'Channel is not in a closed state')
raise TransactionThrew('Update NonClosing balance proof',
receipt_or_none)
log.info(
'updateNonClosingBalanceProof successful',
token_network=pex(self.address),
node=pex(self.node_address),
partner=pex(partner),
nonce=nonce,
balance_hash=encode_hex(balance_hash),
additional_hash=encode_hex(additional_hash),
partner_signature=encode_hex(partner_signature),
signature=encode_hex(signature),
)
def close(
self,
partner: typing.Address,
nonce: typing.Nonce,
balance_hash: typing.BalanceHash,
additional_hash: typing.AdditionalHash,
signature: typing.Signature,
):
""" Close the channel using the provided balance proof.
Raises:
ChannelBusyError: If the channel is busy with another operation.
"""
log.info(
'close called',
token_network=pex(self.address),
node=pex(self.node_address),
partner=pex(partner),
nonce=nonce,
balance_hash=encode_hex(balance_hash),
additional_hash=encode_hex(additional_hash),
signature=encode_hex(signature),
)
self._check_channel_lock(partner)
with releasing(self.channel_operations_lock[partner]):
transaction_hash = self.proxy.transact(
'closeChannel',
partner,
balance_hash,
nonce,
additional_hash,
signature,
)
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.critical(
'close failed',
token_network=pex(self.address),
node=pex(self.node_address),
partner=pex(partner),
nonce=nonce,
balance_hash=encode_hex(balance_hash),
additional_hash=encode_hex(additional_hash),
signature=encode_hex(signature),
)
channel_opened = self.channel_is_opened(partner)
if channel_opened is False:
raise ChannelIncorrectStateError(
'Channel is not in an opened state. It cannot be closed.'
)
raise TransactionThrew('Close', receipt_or_none)
log.info(
'close successful',
token_network=pex(self.address),
node=pex(self.node_address),
partner=pex(partner),
nonce=nonce,
balance_hash=encode_hex(balance_hash),
additional_hash=encode_hex(additional_hash),
signature=encode_hex(signature),
)
def deposit(self, total_deposit: int, partner: typing.Address):
""" Set total token deposit in the channel to total_deposit.
Raises:
ChannelBusyError: If the channel is busy with another operation
RuntimeError: If the token address is empty.
"""
if not isinstance(total_deposit, int):
raise ValueError('total_deposit needs to be an integral number.')
token_address = self.token_address()
token = Token(
self.client,
token_address,
self.poll_timeout,
)
current_balance = token.balance_of(self.node_address)
current_deposit = self.detail_participant(self.node_address,
partner)['deposit']
amount_to_deposit = total_deposit - current_deposit
if amount_to_deposit <= 0:
raise ValueError('deposit [{}] must be greater than 0.'.format(
amount_to_deposit, ))
if current_balance < amount_to_deposit:
raise ValueError(
f'deposit {amount_to_deposit} cant be larger than the '
f'available balance {current_balance}, '
f'for token at address {pex(token_address)}')
log.info(
'deposit called',
token_network=pex(self.address),
node=pex(self.node_address),
partner=pex(partner),
total_deposit=total_deposit,
amount_to_deposit=amount_to_deposit,
)
self._check_channel_lock(partner)
with releasing(self.channel_operations_lock[partner]):
transaction_hash = self.proxy.transact(
'setTotalDeposit',
self.node_address,
total_deposit,
partner,
)
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.critical(
'deposit failed',
token_network=pex(self.address),
node=pex(self.node_address),
partner=pex(partner),
total_deposit=total_deposit,
)
channel_opened = self.channel_is_opened(partner)
if channel_opened is False:
raise ChannelIncorrectStateError(
'Channel is not in an opened state. A deposit cannot be made'
)
raise TransactionThrew('Deposit', receipt_or_none)
log.info(
'deposit successful',
token_network=pex(self.address),
node=pex(self.node_address),
partner=pex(partner),
total_deposit=total_deposit,
)
def settle(
self,
channel_identifier: typing.ChannelID,
transferred_amount: int,
locked_amount: int,
locksroot: typing.Locksroot,
partner: typing.Address,
partner_transferred_amount: int,
partner_locked_amount: int,
partner_locksroot: typing.Locksroot,
):
""" Settle the channel.
Raises:
ChannelBusyError: If the channel is busy with another operation
"""
log_details = {
'token_network': pex(self.address),
'node': pex(self.node_address),
'partner': pex(partner),
'transferred_amount': transferred_amount,
'locked_amount': locked_amount,
'locksroot': encode_hex(locksroot),
'partner_transferred_amount': partner_transferred_amount,
'partner_locked_amount': partner_locked_amount,
'partner_locksroot': encode_hex(partner_locksroot),
}
log.info('settle called', **log_details)
self._check_for_outdated_channel(
self.node_address,
partner,
channel_identifier,
)
with self.channel_operations_lock[partner]:
if self._verify_settle_state(
transferred_amount,
locked_amount,
locksroot,
partner,
partner_transferred_amount,
partner_locked_amount,
partner_locksroot,
) is False:
raise ChannelIncorrectStateError(
'local state can not be used to call settle')
our_maximum = transferred_amount + locked_amount
partner_maximum = partner_transferred_amount + partner_locked_amount
# The second participant transferred + locked amount must be higher
our_bp_is_larger = our_maximum > partner_maximum
if our_bp_is_larger:
transaction_hash = self.proxy.transact(
'settleChannel',
partner,
partner_transferred_amount,
partner_locked_amount,
partner_locksroot,
self.node_address,
transferred_amount,
locked_amount,
locksroot,
)
else:
transaction_hash = self.proxy.transact(
'settleChannel',
self.node_address,
transferred_amount,
locked_amount,
locksroot,
partner,
partner_transferred_amount,
partner_locked_amount,
partner_locksroot,
)
self.client.poll(transaction_hash)
receipt_or_none = check_transaction_threw(self.client,
transaction_hash)
if receipt_or_none:
channel_exists = self.channel_exists(self.node_address,
partner)
if not channel_exists:
log.info('settle failed, channel already settled',
**log_details)
raise ChannelIncorrectStateError(
'Channel already settled or non-existent', )
channel_closed = self.channel_is_closed(
self.node_address, partner)
if channel_closed is False:
log.info('settle failed, channel is not closed',
**log_details)
raise ChannelIncorrectStateError(
'Channel is not in a closed state. It cannot be settled',
)
log.info('settle failed', **log_details)
raise TransactionThrew('Settle', receipt_or_none)
log.info('settle successful', **log_details)
def set_total_deposit(
self,
channel_identifier: typing.ChannelID,
total_deposit: typing.TokenAmount,
partner: typing.Address,
):
""" Set total token deposit in the channel to total_deposit.
Raises:
ChannelBusyError: If the channel is busy with another operation
RuntimeError: If the token address is empty.
"""
if not isinstance(total_deposit, int):
raise ValueError('total_deposit needs to be an integral number.')
self._check_for_outdated_channel(
self.node_address,
partner,
channel_identifier,
)
token_address = self.token_address()
token = Token(self.client, token_address)
with self.channel_operations_lock[partner], self.deposit_lock:
# setTotalDeposit requires a monotonically increasing value. This
# is used to handle concurrent actions:
#
# - The deposits will be done in order, i.e. the monotonic
# property is preserved by the caller
# - The race of two deposits will be resolved with the larger
# deposit winning
# - Retries wont have effect
#
# This check is serialized with the channel_operations_lock to avoid
# sending invalid transactions on-chain (decreasing total deposit).
#
current_deposit = self.detail_participant(self.node_address,
partner)['deposit']
amount_to_deposit = total_deposit - current_deposit
if total_deposit < current_deposit:
raise DepositMismatch(
f'Current deposit ({current_deposit}) is already larger '
f'than the requested total deposit amount ({total_deposit})',
)
if amount_to_deposit <= 0:
raise ValueError(
f'deposit {amount_to_deposit} must be greater than 0.')
# A node may be setting up multiple channels for the same token
# concurrently. Because each deposit changes the user balance this
# check must be serialized with the operation locks.
#
# This check is merely informational, used to avoid sending
# transactions which are known to fail.
#
# It is serialized with the deposit_lock to avoid sending invalid
# transactions on-chain (account without balance). The lock
# channel_operations_lock is not sufficient, as it allows two
# concurrent deposits for different channels.
#
current_balance = token.balance_of(self.node_address)
if current_balance < amount_to_deposit:
raise ValueError(
f'deposit {amount_to_deposit} can not be larger than the '
f'available balance {current_balance}, '
f'for token at address {pex(token_address)}', )
# If there are channels being set up concurrenlty either the
# allowance must be accumulated *or* the calls to `approve` and
# `setTotalDeposit` must be serialized. This is necessary otherwise
# the deposit will fail.
#
# Calls to approve and setTotalDeposit are serialized with the
# deposit_lock to avoid transaction failure, because with two
# concurrent deposits, we may have the transactions executed in the
# following order
#
# - approve
# - approve
# - setTotalDeposit
# - setTotalDeposit
#
# in which case the second `approve` will overwrite the first,
# and the first `setTotalDeposit` will consume the allowance,
# making the second deposit fail.
token.approve(self.address, amount_to_deposit)
log_details = {
'token_network': pex(self.address),
'node': pex(self.node_address),
'partner': pex(partner),
'total_deposit': total_deposit,
'amount_to_deposit': amount_to_deposit,
'id': id(self),
}
log.info('deposit called', **log_details)
transaction_hash = self.proxy.transact(
'setTotalDeposit',
self.node_address,
total_deposit,
partner,
)
self.client.poll(transaction_hash)
receipt_or_none = check_transaction_threw(self.client,
transaction_hash)
if receipt_or_none:
if token.allowance(self.node_address,
self.address) < amount_to_deposit:
log_msg = (
'deposit failed. The allowance is insufficient, check concurrent deposits '
'for the same token network but different proxies.')
elif token.balance_of(self.node_address) < amount_to_deposit:
log_msg = 'deposit failed. The address doesnt have funds'
else:
log_msg = 'deposit failed'
log.critical(log_msg, **log_details)
channel_opened = self.channel_is_opened(
self.node_address, partner)
if channel_opened is False:
raise ChannelIncorrectStateError(
'Channel is not in an opened state. A deposit cannot be made',
)
raise TransactionThrew('Deposit', receipt_or_none)
log.info('deposit successful', **log_details)