Enum ExExNotification

pub enum ExExNotification<P = EthPrimitives>
where
    P: NodePrimitives,
{
    ChainCommitted {
        new: Arc<Chain<P>>,
    },
    ChainReorged {
        old: Arc<Chain<P>>,
        new: Arc<Chain<P>>,
    },
    ChainReverted {
        old: Arc<Chain<P>>,
    },
}

Notifications sent to an ExEx.

Variants

ChainCommitted

Chain got committed without a reorg, and only the new chain is returned.

Fields

new: Arc<Chain<P>>

The new chain after commit.

ChainReorged

Chain got reorged, and both the old and the new chains are returned.

Fields

old: Arc<Chain<P>>

The old chain before reorg.

new: Arc<Chain<P>>

The new chain after reorg.

ChainReverted

Chain got reverted, and only the old chain is returned.

Fields

old: Arc<Chain<P>>

The old chain before reversion.

Implementations

impl ExExNotification

pub fn committed_chain(&self) -> Option<Arc<Chain>>

Returns the committed chain from the Self::ChainCommitted and Self::ChainReorged variants, if any.

pub fn reverted_chain(&self) -> Option<Arc<Chain>>

Returns the reverted chain from the Self::ChainReorged and Self::ChainReverted variants, if any.

pub fn into_inverted(self) -> ExExNotification

Converts the notification into a notification that is the inverse of the original one.

• For Self::ChainCommitted, it’s Self::ChainReverted.
• For Self::ChainReverted, it’s Self::ChainCommitted.
• For Self::ChainReorged, it’s Self::ChainReorged with the new chain as the old chain and the old chain as the new chain.

Trait Implementations

impl<P> Clone for ExExNotification<P>

where P: Clone + NodePrimitives,

fn clone(&self) -> ExExNotification<P>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<P> Debug for ExExNotification<P>

where P: Debug + NodePrimitives,

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

Formats the value using the given formatter.

impl<'de, P> Deserialize<'de> for ExExNotification<P>

where P: NodePrimitives + Deserialize<'de>,

fn deserialize<__D>( __deserializer: __D, ) -> Result<ExExNotification<P>, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<'de> DeserializeAs<'de, ExExNotification> for ExExNotification<'de>

fn deserialize_as<D>( deserializer: D, ) -> Result<ExExNotification, <D as Deserializer<'de>>::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<'a> From<&'a ExExNotification> for ExExNotification<'a>

fn from(value: &'a ExExNotification) -> ExExNotification<'a>

Converts to this type from the input type.

impl<P> From<CanonStateNotification<P>> for ExExNotification<P>

where P: NodePrimitives,

fn from(notification: CanonStateNotification<P>) -> ExExNotification<P>

Converts to this type from the input type.

impl<'a> From<ExExNotification<'a>> for ExExNotification

fn from(value: ExExNotification<'a>) -> ExExNotification

Converts to this type from the input type.

impl<P> PartialEq for ExExNotification<P>

where P: PartialEq + NodePrimitives,

fn eq(&self, other: &ExExNotification<P>) -> 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<P> Serialize for ExExNotification<P>

where P: NodePrimitives + Serialize,

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl SerializeAs<ExExNotification> for ExExNotification<'_>

fn serialize_as<S>( source: &ExExNotification, serializer: S, ) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.

impl<P> Eq for ExExNotification<P>

where P: Eq + NodePrimitives,

impl<P> StructuralPartialEq for ExExNotification<P>

where P: NodePrimitives,

Layout

Note: Most layout information is completely unstable and may even differ between compilations. The only exception is types with certain repr(...) attributes. Please see the Rust Reference's “Type Layout” chapter for details on type layout guarantees.

Size: 24 bytes

Size for each variant:

• ChainCommitted: 8 bytes
• ChainReorged: 16 bytes
• ChainReverted: 8 bytes