Struct raiden_network_messages::messages::Unlock

pub struct Unlock {
    pub message_identifier: MessageIdentifier,
    pub payment_identifier: PaymentIdentifier,
    pub chain_id: ChainID,
    pub token_network_address: TokenNetworkAddress,
    pub channel_identifier: U256,
    pub transferred_amount: TokenAmount,
    pub locked_amount: LockedAmount,
    pub locksroot: Locksroot,
    pub nonce: U256,
    pub secret: Secret,
    pub signature: Signature,
}

Message used to successfully unlock a lock.

For this message to be valid the balance proof has to be updated to:

• Remove the successful lock from the pending locks and decrement the locked_amount by the lock’s amount, otherwise the sender will pay twice.
• Increase the transferred_amount, otherwise the recipient will reject it because it is not being paid. This message is needed to unlock off-chain transfers for channels that used less frequently then the pending locks’ expiration, otherwise the receiving end would have to go on-chain to register the secret.

This message is needed in addition to the RevealSecret to fix synchronization problems. The recipient can not preemptively update its channel state because there may other messages in-flight. Consider the following case:

1. Node A sends a LockedTransfer to B.
2. Node B forwards and eventually receives the secret
3. Node A sends a second LockedTransfer to B.

At point 3, node A had no knowledge about the first payment having its secret revealed, therefore the pending locks from message at step 3 will include both locks. If B were to preemptively remove the lock it would reject the message.

Fields

message_identifier: MessageIdentifier

payment_identifier: PaymentIdentifier

chain_id: ChainID

token_network_address: TokenNetworkAddress

channel_identifier: U256

transferred_amount: TokenAmount

locked_amount: LockedAmount

locksroot: Locksroot

nonce: U256

secret: Secret

signature: Signature

Trait Implementations

impl Clone for Unlock

fn clone(&self) -> Unlock

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Unlock

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Unlock

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl From<SendUnlock> for Unlock

fn from(event: SendUnlock) -> Self

Converts to this type from the input type.

impl PartialEq for Unlock

fn eq(&self, other: &Unlock) -> 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 Unlock

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl SignedEnvelopeMessage for Unlock

fn message_hash(&self) -> H256

impl SignedMessage for Unlock

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 Unlock

impl StructuralPartialEq for Unlock