code: def receive_message(self, message: Message):
          
          self.raiden.on_message(message)
  
          # Sending Delivered after the message is decoded and *processed*
          # gives a stronger guarantee than what is required from a
          # transport.
          #
          # Alternatives are, from weakest to strongest options:
          # - Just save it on disk and asynchronously process the messages
          # - Decode it, save to the WAL, and asynchronously process the
          #   state change
          # - Decode it, save to the WAL, and process it (the current
          #   implementation)
          delivered_message = Delivered(delivered_message_identifier=message.message_identifier)
          self.raiden.sign(delivered_message)
  
          self.maybe_send(
              message.sender,
              delivered_message,
          )
docs: Handle a Raiden protocol message.
  
          The protocol requires durability of the messages. The UDP transport
          relies on the node's WAL for durability. The message will be converted
          to a state change, saved to the WAL, and *processed* before the
          durability is confirmed, which is a stronger property than what is
          required of any transport.