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
