Struct raiden_network_messages::messages::Processed

pub struct Processed {
    pub message_identifier: MessageIdentifier,
    pub signature: Signature,
}

Used by the recipient when a message which has to be validated against blockchain data was successfully processed.

This message is only used to confirm the processing of messages which have some blockchain related data, where receiving the message is not sufficient. Consider the following scenario:

• Node A starts a deposit of 5 tokens.
• Node A sees the deposit, and starts a transfer.
• Node B receives the transfer, however it has not seen the deposit, therefore the transfer is rejected.

Second scenario:

• Node A has a lock which has expired, and sends the RemoveExpiredLock message.
• Node B receives the message, but from its perspective the block at which the lock expires has not been confirmed yet, meaning that a reorg is possible and the secret can be registered on-chain.

For both scenarios A has to keep retrying until B accepts the message.

Notes: - This message is required even if the transport guarantees durability of the data. - This message provides a stronger guarantee then a Delivered, therefore it can replace it.

Fields

message_identifier: MessageIdentifier

signature: Signature

Trait Implementations

impl Clone for Processed

fn clone(&self) -> Processed

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Processed

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Processed

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl From<SendProcessed> for Processed

fn from(event: SendProcessed) -> Self

Converts to this type from the input type.

impl PartialEq for Processed

fn eq(&self, other: &Processed) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for Processed

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl SignedMessage for Processed

fn bytes_to_sign(&self) -> Vec<u8>

fn sign(&mut self, key: PrivateKey) -> Result<(), SigningError>

fn sign_message(&self, key: PrivateKey) -> Result<Signature, SigningError>

impl Eq for Processed

impl StructuralPartialEq for Processed