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)