Struct ContractSendChannelBatchUnlock 

pub struct ContractSendChannelBatchUnlock {
    pub inner: ContractSendEventInner,
    pub canonical_identifier: CanonicalIdentifier,
    pub sender: Address,
}

Look for unlocks that we should do after settlement

This will only lead to an on-chain unlock if there are locks that can be unlocked to our benefit.

Usually, we would check if this is the case in the state machine and skip the creation of this event if no profitable locks are found. But if a channel was closed with another BP than the latest one, we need to look in the database for the locks that correspond to the on-chain data. Searching the database is not possible in the state machine, so we create this event in every case and do the check in the event handler. Since locks for both receiving and sending transfers can potentially return tokens to use, this event leads to 0-2 on-chain transactions.

Fields

inner: ContractSendEventInner

canonical_identifier: CanonicalIdentifier

sender: Address

Trait Implementations

impl Clone for ContractSendChannelBatchUnlock

fn clone(&self) -> ContractSendChannelBatchUnlock

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ContractSendChannelBatchUnlock

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

Formats the value using the given formatter.

impl Deref for ContractSendChannelBatchUnlock

type Target = ContractSendEventInner

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<'de> Deserialize<'de> for ContractSendChannelBatchUnlock

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Into<Event> for ContractSendChannelBatchUnlock

fn into(self) -> Event

Converts this type into the (usually inferred) input type.

impl PartialEq for ContractSendChannelBatchUnlock

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

Tests for self and other values to be equal, and is used by ==.

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

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

impl Serialize for ContractSendChannelBatchUnlock

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for ContractSendChannelBatchUnlock

impl StructuralPartialEq for ContractSendChannelBatchUnlock