def register_transfer(self, transfer):
""" Register a signed transfer, updating the channel's state accordingly. """
if transfer.recipient == self.partner_state.address:
self.register_transfer_from_to(
transfer,
from_state=self.our_state,
to_state=self.partner_state,
)
self.sent_transfers.append(transfer)
elif transfer.recipient == self.our_state.address:
self.register_transfer_from_to(
transfer,
from_state=self.partner_state,
to_state=self.our_state,
)
self.received_transfers.append(transfer)
else:
if log.isEnabledFor(logging.WARN):
log.warn(
'Received a transfer from %s with recipient %s who is not '
'a part of the channel',
pex(transfer.sender),
pex(transfer.recipient),
)
raise UnknownAddress(transfer)
def register_transfer(self, block_number, transfer):
""" Register a signed transfer, updating the channel's state accordingly. """
if transfer.sender == self.our_state.address:
self.register_transfer_from_to(
block_number,
transfer,
from_state=self.our_state,
to_state=self.partner_state,
)
self.sent_transfers.append(transfer)
elif transfer.sender == self.partner_state.address:
self.register_transfer_from_to(
block_number,
transfer,
from_state=self.partner_state,
to_state=self.our_state,
)
self.received_transfers.append(transfer)
else:
if log.isEnabledFor(logging.WARN):
log.warn(
'Received a transfer from party that is not a part of the channel',
node=self.our_state.address,
from_=pex(transfer.sender),
channel=pex(transfer.channel))
raise UnknownAddress(transfer)
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)
if message.token in self.blocked_tokens:
raise TransferUnwanted()
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_refundtransfer(self, message):
self.balance_proof(message)
graph = self.raiden.token_to_channelgraph[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_to_channel[message.sender]
channel.register_transfer(
self.raiden.get_block_number(),
message,
)
transfer_state = LockedTransferState(
identifier=message.identifier,
amount=message.lock.amount,
token=message.token,
initiator=message.initiator,
target=message.target,
expiration=message.lock.expiration,
hashlock=message.lock.hashlock,
secret=None,
)
state_change = ReceiveTransferRefund(
message.sender,
transfer_state,
)
self.raiden.state_machine_event_handler.log_and_dispatch_by_identifier(
message.identifier,
state_change,
)
def endpoint_by_address(self, node_address_bin):
node_address_hex = node_address_bin.encode('hex')
endpoint = self.proxy.findEndpointByAddress(node_address_hex)
if endpoint is '':
raise UnknownAddress('Unknown address {}'.format(pex(node_address_bin)))
return endpoint
def endpoint_by_address(self, node_address_bin):
node_address_hex = hexlify(node_address_bin)
endpoint = self.proxy.call('findEndpointByAddress', node_address_hex)
if endpoint == b'':
raise UnknownAddress('Unknown address {}'.format(pex(node_address_bin)))
return endpoint
def endpoint_by_address(self, node_address_bin):
node_address_hex = to_checksum_address(node_address_bin)
endpoint = self.proxy.contract.functions.findEndpointByAddress(
node_address_hex,
).call()
if endpoint == '':
raise UnknownAddress('Unknown address {}'.format(pex(node_address_bin)))
return endpoint
def message_directtransfer(self, message):
self.balance_proof(message)
if message.token not in self.raiden.token_to_channelgraph:
raise UnknownTokenAddress('Unknown token address {}'.format(pex(message.token)))
if message.token in self.blocked_tokens:
raise TransferUnwanted()
graph = self.raiden.token_to_channelgraph[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_to_channel[message.sender]
if channel.state != CHANNEL_STATE_OPENED:
raise TransferWhenClosed(
'Direct transfer received for a closed channel: {}'.format(
pex(channel.channel_address),
)
)
amount = message.transferred_amount - channel.partner_state.transferred_amount
state_change = ReceiveTransferDirect(
message.identifier,
amount,
message.token,
message.sender,
)
state_change_id = self.raiden.transaction_log.log(state_change)
channel.register_transfer(
self.raiden.get_block_number(),
message,
)
receive_success = EventTransferReceivedSuccess(
message.identifier,
amount,
message.sender,
)
self.raiden.transaction_log.log_events(
state_change_id,
[receive_success],
self.raiden.get_block_number()
)
def message_directtransfer(self, message):
if message.token not in self.raiden.channelgraphs:
raise UnknownTokenAddress('Unknown token address {}'.format(
pex(message.token)))
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 channel.state != CHANNEL_STATE_OPENED:
raise TransferWhenClosed(
'Direct transfer received for a closed channel: {}'.format(
pex(channel.channel_address), ))
channel.register_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 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,
)
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)
