Struct raiden_network_messages::messages::LockedTransfer

pub struct LockedTransfer {

    pub message_identifier: MessageIdentifier,
    pub payment_identifier: PaymentIdentifier,
    pub chain_id: ChainID,
    pub token_network_address: TokenNetworkAddress,
    pub channel_identifier: ChannelIdentifier,
    pub transferred_amount: TokenAmount,
    pub locked_amount: LockedAmount,
    pub locksroot: Locksroot,
    pub token: TokenAddress,
    pub recipient: Address,
    pub lock: Lock,
    pub target: Address,
    pub initiator: Address,
    pub metadata: Metadata,
    pub nonce: U256,
    pub secret: Option<Secret>,
    pub signature: Signature,
}

Message used to reserve tokens for a new mediated transfer.

For this message to be valid, the sender must:

• Use a lock.amount smaller then its current capacity. If the amount is higher, then the recipient will reject it, as it means spending money it does not own.
• Have the new lock represented in locksroot.
• Increase the locked_amount by exactly lock.amount otherwise the message would be rejected by the recipient. If the locked_amount is increased by more, then funds may get locked in the channel. If the locked_amount is increased by less, then the recipient will reject the message as it may mean it received the funds with an on-chain unlock. The initiator will estimate the fees based on the available routes and incorporate it in the lock’s amount. Note that with permissive routing it is not possible to predetermine the exact fee amount, as the initiator does not know which nodes are available, thus an estimated value is used.

Fields

message_identifier: MessageIdentifier

payment_identifier: PaymentIdentifier

chain_id: ChainID

token_network_address: TokenNetworkAddress

channel_identifier: ChannelIdentifier

transferred_amount: TokenAmount

locked_amount: LockedAmount

locksroot: Locksroot

token: TokenAddress

recipient: Address

lock: Lock

target: Address

initiator: Address

metadata: Metadata

nonce: U256

secret: Option<Secret>

signature: Signature

Trait Implementations

impl Clone for LockedTransfer

fn clone(&self) -> LockedTransfer

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for LockedTransfer

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for LockedTransfer

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl From<SendLockedTransfer> for LockedTransfer

fn from(event: SendLockedTransfer) -> Self

Converts to this type from the input type.

impl PartialEq for LockedTransfer

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

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 LockedTransfer

fn message_hash(&self) -> H256

impl SignedMessage for LockedTransfer

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 LockedTransfer

impl StructuralPartialEq for LockedTransfer