Struct bp_messages::InboundLaneData

pub struct InboundLaneData<RelayerId> {
    pub relayers: VecDeque<UnrewardedRelayer<RelayerId>>,
    pub last_confirmed_nonce: MessageNonce,
    pub state: LaneState,
}

Inbound lane data.

Fields

relayers: VecDeque<UnrewardedRelayer<RelayerId>>

Identifiers of relayers and messages that they have delivered to this lane (ordered by message nonce).

This serves as a helper storage item, to allow the source chain to easily pay rewards to the relayers who successfully delivered messages to the target chain (inbound lane).

It is guaranteed to have at most N entries, where N is configured at the module level. If there are N entries in this vec, then:

1. all incoming messages are rejected if they’re missing corresponding proof-of(outbound-lane.state); 2) all incoming messages are rejected if proof-of(outbound-lane.state).last_delivered_nonce is equal to self.last_confirmed_nonce. Given what is said above, all nonces in this queue are in range: (self.last_confirmed_nonce; self.last_delivered_nonce()].

When a relayer sends a single message, both of MessageNonces are the same. When relayer sends messages in a batch, the first arg is the lowest nonce, second arg the highest nonce. Multiple dispatches from the same relayer are allowed.

last_confirmed_nonce: MessageNonce

Nonce of the last message that a) has been delivered to the target (this) chain and b) the delivery has been confirmed on the source chain

that the target chain knows of.

This value is updated indirectly when an OutboundLane state of the source chain is received alongside with new messages delivery.

state: LaneState

Inbound lane state.

If state is Closed, then all attempts to deliver messages to this end will fail.

Implementations

impl<RelayerId> InboundLaneData<RelayerId>

pub fn opened() -> Self

Returns default inbound lane data with opened state.

pub fn encoded_size_hint(relayers_entries: usize) -> Option<usize>

where RelayerId: MaxEncodedLen,

Returns approximate size of the struct, given a number of entries in the relayers set and size of each entry.

Returns None if size overflows usize limits.

pub fn encoded_size_hint_u32(relayers_entries: usize) -> u32

where RelayerId: MaxEncodedLen,

Returns the approximate size of the struct as u32, given a number of entries in the relayers set and the size of each entry.

Returns u32::MAX if size overflows u32 limits.

pub fn last_delivered_nonce(&self) -> MessageNonce

Nonce of the last message that has been delivered to this (target) chain.

pub fn total_unrewarded_messages(&self) -> MessageNonce

Returns the total number of messages in the relayers vector, saturating in case of underflow or overflow.

Trait Implementations

impl<RelayerId: Clone> Clone for InboundLaneData<RelayerId>

fn clone(&self) -> InboundLaneData<RelayerId>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<RelayerId> Debug for InboundLaneData<RelayerId>

where RelayerId: Debug,

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

Formats the value using the given formatter.

impl<RelayerId> Decode for InboundLaneData<RelayerId>

where VecDeque<UnrewardedRelayer<RelayerId>>: Decode,

fn decode<__CodecInputEdqy: Input>( __codec_input_edqy: &mut __CodecInputEdqy, ) -> Result<Self, Error>

Attempt to deserialise the value from input.

fn decode_into<I>( input: &mut I, dst: &mut MaybeUninit<Self>, ) -> Result<DecodeFinished, Error>

where I: Input,

Attempt to deserialize the value from input into a pre-allocated piece of memory.

fn skip<I>(input: &mut I) -> Result<(), Error>

where I: Input,

Attempt to skip the encoded value from input.

fn encoded_fixed_size() -> Option<usize>

Returns the fixed encoded size of the type.

impl<RelayerId> Default for InboundLaneData<RelayerId>

fn default() -> Self

Returns the “default value” for a type.

impl<RelayerId> Encode for InboundLaneData<RelayerId>

where VecDeque<UnrewardedRelayer<RelayerId>>: Encode,

fn size_hint(&self) -> usize

If possible give a hint of expected size of the encoding.

fn encode_to<__CodecOutputEdqy: Output + ?Sized>( &self, __codec_dest_edqy: &mut __CodecOutputEdqy, )

Convert self to a slice and append it to the destination.

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

Convert self to an owned vector.

fn using_encoded<R, F>(&self, f: F) -> R

where F: FnOnce(&[u8]) -> R,

Convert self to a slice and then invoke the given closure with it.

fn encoded_size(&self) -> usize

Calculates the encoded size.

impl<RelayerId> From<&InboundLaneData<RelayerId>> for UnrewardedRelayersState

fn from(lane: &InboundLaneData<RelayerId>) -> UnrewardedRelayersState

Converts to this type from the input type.

impl<RelayerId: PartialEq> PartialEq for InboundLaneData<RelayerId>

fn eq(&self, other: &InboundLaneData<RelayerId>) -> 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<RelayerId> TypeInfo for InboundLaneData<RelayerId>

where VecDeque<UnrewardedRelayer<RelayerId>>: TypeInfo + 'static, RelayerId: TypeInfo + 'static,

type Identity = InboundLaneData<RelayerId>

The type identifying for which type info is provided.

fn type_info() -> Type

Returns the static type identifier for Self.

impl<RelayerId> EncodeLike for InboundLaneData<RelayerId>

where VecDeque<UnrewardedRelayer<RelayerId>>: Encode,

impl<RelayerId: Eq> Eq for InboundLaneData<RelayerId>

impl<RelayerId> StructuralPartialEq for InboundLaneData<RelayerId>