def message_tokenswap(self, message): key = SwapKey( message.identifier, message.token, message.lock.amount, ) # If we are the maker the task is already running and waiting for the # taker's MediatedTransfer task = self.raiden.swapkeys_greenlettasks.get(key) if task: task.response_queue.put(message) # If we are the taker we are receiving the maker transfer and should # start our new task else: token_swap = self.raiden.swapkeys_tokenswaps[key] task = TakerTokenSwapTask( self.raiden, token_swap, message, ) task.start() self.raiden.swapkeys_greenlettasks[key] = task
def expect_token_swap(self, identifier, maker_token, maker_amount, maker_address, taker_token, taker_amount, taker_address): """ Register an expected transfer for this node. If a MediatedMessage is received for the `maker_asset` with `maker_amount` then proceed to send a MediatedTransfer to `maker_address` for `taker_asset` with `taker_amount`. """ if not isaddress(maker_token): raise InvalidAddress( 'Address for maker token is not in expected binary format in expect_token_swap' ) if not isaddress(maker_address): raise InvalidAddress( 'Address for maker is not in expected binary format in expect_token_swap' ) if not isaddress(taker_token): raise InvalidAddress( 'Address for taker token is not in expected binary format in expect_token_swap' ) if not isaddress(taker_address): raise InvalidAddress( 'Address for taker is not in expected binary format in expect_token_swap' ) channelgraphs = self.raiden.token_to_channelgraph if taker_token not in channelgraphs: log.error('Unknown token {}'.format(pex(taker_token))) return if maker_token not in channelgraphs: log.error('Unknown token {}'.format(pex(maker_token))) return # the taker is expecting the maker transfer key = SwapKey( identifier, maker_token, maker_amount, ) token_swap = TokenSwap( identifier, maker_token, maker_amount, maker_address, taker_token, taker_amount, taker_address, ) self.raiden.swapkey_to_tokenswap[key] = token_swap
def message_mediatedtransfer(self, message): self.balance_proof(message) # TODO: Reject mediated transfer that the hashlock/identifier is known, # this is a downstream bug and the transfer is going in cycles (issue #490) key = SwapKey( message.identifier, message.token, message.lock.amount, ) if message.token in self.blocked_tokens: raise TransferUnwanted() # TODO: add a separate message for token swaps to simplify message # handling (issue #487) if key in self.raiden.swapkey_to_tokenswap: self.message_tokenswap(message) return graph = self.raiden.token_to_channelgraph[message.token] if not graph.has_channel(self.raiden.address, message.sender): raise UnknownAddress( 'Mediated transfer from node without an existing channel: {}'.format( pex(message.sender), ) ) channel = graph.partneraddress_to_channel[message.sender] if channel.state != CHANNEL_STATE_OPENED: raise TransferWhenClosed( 'Mediated transfer received but the channel is closed: {}'.format( pex(channel.channel_address), ) ) # raises if the message is invalid channel.register_transfer( self.raiden.get_block_number(), message ) if message.target == self.raiden.address: self.raiden.target_mediated_transfer(message) else: self.raiden.mediate_mediated_transfer(message)
def message_mediatedtransfer(self, message): # TODO: Reject mediated transfer that the hashlock/identifier is known, # this is a downstream bug and the transfer is going in cycles (issue #490) key = SwapKey( message.identifier, message.token, message.lock.amount, ) # TODO: add a separate message for token swaps to simplify message # handling (issue #487) if key in self.raiden.swapkeys_tokenswaps: self.message_tokenswap(message) return graph = self.raiden.channelgraphs[message.token] if not graph.has_channel(self.raiden.address, message.sender): raise UnknownAddress( 'Direct transfer from node without an existing channel: {}'.format( pex(message.sender), ) ) channel = graph.partneraddress_channel[message.sender] if not channel.isopen: raise TransferWhenClosed( 'Direct transfer received for a closed channel: {}'.format( pex(channel.channel_address), ) ) channel.register_transfer(message) # raises if the message is invalid if message.target == self.raiden.address: self.raiden.target_mediated_transfer(message) else: self.raiden.mediate_mediated_transfer(message)
def token_swap_async(self, identifier, maker_token, maker_amount, maker_address, taker_token, taker_amount, taker_address): """ Start a token swap operation by sending a MediatedTransfer with `maker_amount` of `maker_token` to `taker_address`. Only proceed when a new valid MediatedTransfer is received with `taker_amount` of `taker_token`. """ if not isaddress(maker_token): raise InvalidAddress( 'Address for maker token is not in expected binary format in token swap' ) if not isaddress(maker_address): raise InvalidAddress( 'Address for maker is not in expected binary format in token swap' ) if not isaddress(taker_token): raise InvalidAddress( 'Address for taker token is not in expected binary format in token swap' ) if not isaddress(taker_address): raise InvalidAddress( 'Address for taker is not in expected binary format in token swap' ) channelgraphs = self.raiden.token_to_channelgraph if taker_token not in channelgraphs: log.error('Unknown token {}'.format(pex(taker_token))) return if maker_token not in channelgraphs: log.error('Unknown token {}'.format(pex(maker_token))) return token_swap = TokenSwap( identifier, maker_token, maker_amount, maker_address, taker_token, taker_amount, taker_address, ) async_result = AsyncResult() task = MakerTokenSwapTask( self.raiden, token_swap, async_result, ) task.start() # the maker is expecting the taker transfer key = SwapKey( identifier, taker_token, taker_amount, ) self.raiden.swapkey_to_greenlettask[key] = task self.raiden.swapkey_to_tokenswap[key] = token_swap return async_result