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)