def _receive_delivered(self, delivered: Delivered):
        # FIXME: The signature doesn't seem to be verified - check in UDPTransport as well
        self._raiden_service.handle_state_change(
            ReceiveDelivered(delivered.delivered_message_identifier),
        )

        async_result = self._messageids_to_asyncresult.pop(
            delivered.delivered_message_identifier,
            None,
        )

        if async_result is not None:
            async_result.set(True)
            self.log.debug(
                'DELIVERED MESSAGE RECEIVED',
                node=pex(self._raiden_service.address),
                receiver=pex(delivered.sender),
                message_identifier=delivered.delivered_message_identifier,
            )

        else:
            self.log.debug(
                'DELIVERED MESSAGE UNKNOWN',
                node=pex(self._raiden_service.address),
                message_identifier=delivered.delivered_message_identifier,
            )

 def __repr__(self):
     return '<{} [hashlock:{} amount:{} hash:{}]>'.format(
         self.__class__.__name__,
         pex(self.hashlock),
         self.amount,
         pex(self.hash),
     )

    def transfer(self, to_address, amount):
        log_details = {
            'node': pex(self.node_address),
            'contract': pex(self.address),
            'to_address': pex(to_address),
            'amount': amount,
        }
        log.debug('transfer called', **log_details)

        startgas = GAS_LIMIT_FOR_TOKEN_CONTRACT_CALL
        transaction_hash = self.proxy.transact(
            'transfer',
            safe_gas_limit(startgas),
            to_checksum_address(to_address),
            amount,
        )

        self.client.poll(transaction_hash)
        receipt_or_none = check_transaction_threw(self.client, transaction_hash)
        if receipt_or_none:
            log.critical('transfer failed', **log_details)
            raise TransactionThrew('Transfer', receipt_or_none)

        # TODO: check Transfer event (issue: #2598)
        log.info('transfer successful', **log_details)

    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 unlock(self, our_address, unlock_proofs):
        # force a list to get the length (could be a generator)
        unlock_proofs = list(unlock_proofs)
        log.info(
            '%s locks to unlock',
            len(unlock_proofs),
            contract=pex(self.address),
        )

        for merkle_proof, locked_encoded, secret in unlock_proofs:
            if isinstance(locked_encoded, messages.Lock):
                raise ValueError('unlock must be called with a lock encoded `.as_bytes`')

            merkleproof_encoded = ''.join(merkle_proof)

            transaction_hash = self.proxy.unlock.transact(
                locked_encoded,
                merkleproof_encoded,
                secret,
                startgas=self.startgas,
                gasprice=self.gasprice,
            )
            self.client.poll(transaction_hash.decode('hex'), timeout=self.poll_timeout)
            # TODO: check if the ChannelSecretRevealed event was emitted and if
            # it wasn't raise an error

            # if log.getEffectiveLevel() >= logging.INFO:  # only decode the lock if need to
            lock = messages.Lock.from_bytes(locked_encoded)
            log.info(
                'unlock called',
                contract=pex(self.address),
                lock=lock,
                secret=encode_hex(secret),
            )

    def register_locked_transfer(self, locked_transfer):
        if not isinstance(locked_transfer, LockedTransfer):
            raise ValueError('transfer must be LockedTransfer')

        lock = locked_transfer.lock
        lockhashed = sha3(lock.as_bytes)

        if self.is_known(lock.hashlock):
            raise ValueError('hashlock is already registered')

        merkletree = self.unclaimed_merkletree()
        merkletree.append(lockhashed)
        new_locksroot = merkleroot(merkletree)

        if locked_transfer.locksroot != new_locksroot:
            raise ValueError(
                'locksroot mismatch expected:{} got:{}'.format(
                    pex(new_locksroot),
                    pex(locked_transfer.locksroot),
                )
            )

        self.hashlock_pendinglocks[lock.hashlock] = PendingLock(lock, lockhashed)
        self.transfer = locked_transfer
        self.hashlock_unlockedlocks = dict()

    def receive(self, data):
        # ignore large packets
        if len(data) > self.max_message_size:
            log.error('receive packet larger than maximum size', length=len(data))
            return

        msghash = sha3(data)

        # check if we handled this message already, if so repeat Ack
        if msghash in self.sent_acks:
            return self.send_ack(*self.sent_acks[msghash])

        # We ignore the sending endpoint as this can not be known w/ UDP
        msg = messages.decode(data)

        if isinstance(msg, Ack):
            # we might receive the same Ack more than once
            if msg.echo in self.number_of_tries:
                log.debug('ACK RECEIVED {} [echo={}]'.format(
                    pex(self.raiden.address),
                    pex(msg.echo)
                ))

                del self.number_of_tries[msg.echo]
            else:
                log.debug('DUPLICATED ACK RECEIVED {} [echo={}]'.format(
                    pex(self.raiden.address),
                    pex(msg.echo)
                ))
        else:
            assert isinstance(msg, Secret) or msg.sender
            self.raiden.on_message(msg, msghash)

    def _repeat_until_ack(self, receiver_address, msg):
        data = msg.encode()
        host_port = self.discovery.get(receiver_address)

        # msghash is removed from the `number_of_tries` once a Ack is
        # received, resend until we receive it or give up
        msghash = sha3(data)
        self.number_of_tries[msghash] = 0

        log.info('SENDING {} > {} : [{}] {}'.format(
            pex(self.raiden.address),
            pex(receiver_address),
            pex(msghash),
            msg,
        ))

        while msghash in self.number_of_tries:
            if self.number_of_tries[msghash] > self.max_tries:
                # FIXME: suspend node + recover from the failure
                raise Exception('DEACTIVATED MSG resents {} {}'.format(
                    pex(receiver_address),
                    msg,
                ))

            self.number_of_tries[msghash] += 1
            self.transport.send(self.raiden, host_port, data)
            gevent.sleep(self.try_interval)

    def _run(self):  # pylint: disable=method-hidden
        transfer = self.originating_transfer
        assetmanager = self.transfermanager.assetmanager
        raiden = assetmanager.raiden

        transfer_details = '{} -> {} hash:{}'.format(
            pex(transfer.target),
            pex(transfer.initiator),
            pex(transfer.hash),
        )
        log.debug('END MEDIATED TRANSFER {}'.format(transfer_details))

        secret_request = SecretRequest(transfer.lock.hashlock)
        raiden.sign(secret_request)
        raiden.send(transfer.initiator, secret_request)

        self.event = AsyncResult()
        response = self.event.wait(raiden.config['msg_timeout'])

        if response is None:
            log.error('SECRETREQUEST TIMED OUT!')
            self.transfermanager.on_hashlock_result(transfer.hashlock, False)
            return

        if not isinstance(response, Secret):
            raise Exception('Invalid message received.')

        if sha3(response.secret) != transfer.lock.hashlock:
            raise Exception('Invalid secret received.')

        # update all channels and propagate the secret
        assetmanager.register_secret(response.secret)
        self.transfermanager.on_hashlock_result(transfer.lock.hashlock, True)

    def register_endpoint(self, node_address, endpoint):
        if node_address != self.client.address:
            raise ValueError("node_address doesnt match this node's address")

        log_details = {
            'node': pex(self.node_address),
            'node_address': pex(node_address),
            'endpoint': endpoint,
        }
        log.debug('registerEndpoint called', **log_details)

        transaction_hash = self.proxy.transact(
            'registerEndpoint',
            safe_gas_limit(GAS_REQUIRED_FOR_ENDPOINT_REGISTER),
            endpoint,
        )

        self.client.poll(transaction_hash)

        receipt_or_none = check_transaction_threw(self.client, transaction_hash)
        if receipt_or_none:
            log.critical('registerEndpoint failed', **log_details)
            raise TransactionThrew('Register Endpoint', receipt_or_none)

        log.debug('registerEndpoint successful', **log_details)

    def receive(self, messagedata: bytes):
        """ Handle an UDP packet. """
        # pylint: disable=unidiomatic-typecheck

        if len(messagedata) > self.UDP_MAX_MESSAGE_SIZE:
            log.error(
                'INVALID MESSAGE: Packet larger than maximum size',
                node=pex(self.raiden.address),
                message=hexlify(messagedata),
                length=len(messagedata),
            )
            return

        message = decode(messagedata)

        if type(message) == Pong:
            self.receive_pong(message)
        elif type(message) == Ping:
            self.receive_ping(message)
        elif type(message) == Delivered:
            self.receive_delivered(message)
        elif message is not None:
            self.receive_message(message)
        else:
            log.error(
                'INVALID MESSAGE: Unknown cmdid',
                node=pex(self.raiden.address),
                message=hexlify(messagedata),
            )

 def __repr__(self):
     return '<ReceiveSecretRequest paymentid:{} amount:{} secrethash:{} sender:{}>'.format(
         self.payment_identifier,
         self.amount,
         pex(self.secrethash),
         pex(self.sender),
     )

    def __init__(self, expected_locksroot, got_locksroot):
        msg = 'Locksroot mismatch. Expected {} but got {}'.format(
            pex(expected_locksroot),
            pex(got_locksroot),
        )

        super(InvalidLocksRoot, self).__init__(msg)

    def join_channel(self, partner_address, partner_deposit):
        """Will be called, when we were selected as channel partner by another
        node. It will fund the channel with up to the partners deposit, but
        not more than remaining funds or the initial funding per channel.

        If the connection manager has no funds, this is a noop.
        """
        with self.lock:
            joining_funds = min(
                partner_deposit,
                self._funds_remaining,
                self._initial_funding_per_partner,
            )
            if joining_funds <= 0 or self._leaving_state:
                return

            self.api.set_total_channel_deposit(
                self.registry_address,
                self.token_address,
                partner_address,
                joining_funds,
            )
            log.debug(
                'joined a channel!',
                funds=joining_funds,
                me=pex(self.raiden.address),
                partner=pex(partner_address),
            )

    def add_token(self, token_address):
        if not isaddress(token_address):
            raise ValueError('token_address must be a valid address')

        transaction_hash = estimate_and_transact(
            self.proxy,
            'addToken',
            self.startgas,
            self.gasprice,
            token_address,
        )

        self.client.poll(unhexlify(transaction_hash), timeout=self.poll_timeout)
        receipt_or_none = check_transaction_threw(self.client, transaction_hash)
        if receipt_or_none:
            raise TransactionThrew('AddToken', receipt_or_none)

        manager_address = self.manager_address_by_token(token_address)

        if manager_address is None:
            log.error('Transaction failed and check_transaction_threw didnt detect it')
            raise RuntimeError('channelManagerByToken failed')

        if log.isEnabledFor(logging.INFO):
            log.info(
                'add_token called',
                token_address=pex(token_address),
                registry_address=pex(self.address),
                manager_address=pex(manager_address),
            )

        return manager_address

    def __repr__(self):
        representation = (
            '<{} ['
            'chainid:{} msgid:{} paymentid:{} token_network:{} channel:{} '
            'nonce:{} transferred_amount:{} '
            'locked_amount:{} locksroot:{} hash:{} secrethash:{} expiration:{} amount:{}'
            ']>'
        ).format(
            self.__class__.__name__,
            self.chain_id,
            self.message_identifier,
            self.payment_identifier,
            pex(self.token_network_address),
            pex(self.channel),
            self.nonce,
            self.transferred_amount,
            self.locked_amount,
            pex(self.locksroot),
            pex(self.hash),
            pex(self.lock.secrethash),
            self.lock.expiration,
            self.lock.amount,
        )

        return representation

    def close(self, our_address, first_transfer, second_transfer):
        if first_transfer and second_transfer:
            first_encoded = first_transfer.encode()
            second_encoded = second_transfer.encode()

            self.proxy.close(
                first_encoded,
                second_encoded,
            )
            self.tester_state.mine(number_of_blocks=1)
            log.info(
                'close called',
                contract=pex(self.address),
                first_transfer=first_transfer,
                second_transfer=second_transfer,
            )

        elif first_transfer:
            first_encoded = first_transfer.encode()

            self.proxy.closeSingleTransfer(first_encoded)
            self.tester_state.mine(number_of_blocks=1)
            log.info('close called', contract=pex(self.address), first_transfer=first_transfer)

        elif second_transfer:
            second_encoded = second_transfer.encode()

            self.proxy.closeSingleTransfer.transact(second_encoded)
            self.tester_state.mine(number_of_blocks=1)
            log.info('close called', contract=pex(self.address), second_transfer=second_transfer)

        else:
            # TODO: allow to close nevertheless
            raise ValueError('channel wasnt used')

    def unlock(self, our_address, unlock_proofs):
        # force a list to get the length (could be a generator)
        unlock_proofs = list(unlock_proofs)
        log.info('{} locks to unlock'.format(len(unlock_proofs)), contract=pex(self.address))

        for merkle_proof, locked_encoded, secret in unlock_proofs:
            if isinstance(locked_encoded, messages.Lock):
                raise ValueError('unlock must be called with a lock encoded `.as_bytes`')

            merkleproof_encoded = ''.join(merkle_proof)

            self.proxy.unlock(
                locked_encoded,
                merkleproof_encoded,
                secret,
            )
            self.tester_state.mine(number_of_blocks=1)

            lock = messages.Lock.from_bytes(locked_encoded)
            log.info(
                'unlock called',
                contract=pex(self.address),
                lock=lock,
                secret=encode_hex(secret),
            )

    def send_ping(self, receiver_address):
        if not isaddress(receiver_address):
            raise ValueError('Invalid address {}'.format(pex(receiver_address)))

        nonce = self._ping_nonces[receiver_address]
        self._ping_nonces[receiver_address] += 1

        message = Ping(nonce)
        self.raiden.sign(message)

        if log.isEnabledFor(logging.INFO):
            log.info(
                'SENDING PING %s > %s',
                pex(self.raiden.address),
                pex(receiver_address)
            )

        message_data = message.encode()
        echohash = sha3(message_data + receiver_address)
        async_result = AsyncResult()
        if echohash not in self.echohash_asyncresult:
            self.echohash_asyncresult[echohash] = WaitAck(async_result, receiver_address)
        # Just like ACK, a PING message is sent directly. No need for queuing
        self.transport.send(
            self.raiden,
            self.discovery.get(receiver_address),
            message_data
        )
        return async_result

 def __repr__(self):
     return '<{} {} from_token:{} to_token:{}>'.format(
         self.__class__.__name__,
         pex(self.raiden.address),
         pex(self.from_mediated_transfer.token),
         pex(self.tokenswap.to_token),
     )