Struct ac_node_api::events::RawEventDetails

pub struct RawEventDetails<Hash: Decode + Encode> { /* private fields */ }

Raw event details without the associated metadata

Implementations

impl<Hash: Encode + Decode> RawEventDetails<Hash>

pub fn phase(&self) -> Phase

When was the event produced?

pub fn index(&self) -> u32

What index is this event in the stored events for this block.

pub fn pallet_index(&self) -> u8

The index of the pallet that the event originated from.

pub fn variant_index(&self) -> u8

The index of the event variant that the event originated from.

pub fn pallet_name(&self) -> &str

The name of the pallet from whence the Event originated.

pub fn variant_name(&self) -> &str

The name of the event (ie the name of the variant that it corresponds to).

pub fn event_metadata<'a>( &'a self, metadata: &'a Metadata ) -> Result<EventMetadataDetails<'_>, Error>

Fetch details from the metadata for this event.

pub fn bytes(&self) -> &[u8]

Return all of the bytes representing this event, which include, in order:

• The phase.
• Pallet and event index.
• Event fields.
• Event Topics.

pub fn field_bytes(&self) -> &[u8]

Return the bytes representing the fields stored in this event.

pub fn field_values( &self, metadata: &Metadata ) -> Result<Composite<TypeId>, Error>

Decode and provide the event fields back in the form of a scale_value::Composite type which represents the named or unnamed fields that were present in the event.

pub fn as_event<E: StaticEvent>(&self) -> Result<Option<E>, Error>

Attempt to decode these EventDetails into a specific static event. This targets the fields within the event directly. You can also attempt to decode the entirety of the event type (including the pallet and event variants) using EventDetails::as_root_event().

pub fn as_root_event<E: RootEvent>( &self, metadata: &Metadata ) -> Result<E, Error>

Attempt to decode these EventDetails into a root event type (which includes the pallet and event enum variants as well as the event fields). A compatible type for this is exposed via static codegen as a root level Event type.

pub fn topics(&self) -> &[Hash]

Return the topics associated with this event.

pub fn pallet_bytes(&self) -> &[u8]

impl<Hash: Encode + Decode> RawEventDetails<Hash>

pub fn has_failed(&self) -> bool

Checks if the extrinsic has failed.

pub fn get_associated_dispatch_error( &self, metadata: &Metadata ) -> Option<DispatchError>

Returns the dispatch error of the failed extrinsic, if it has failed.

pub fn is_code_update(&self) -> bool

Checks if the event represents a code update (runtime update).

Trait Implementations

impl<Hash: Clone + Decode + Encode> Clone for RawEventDetails<Hash>

fn clone(&self) -> RawEventDetails<Hash>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<Hash: Debug + Decode + Encode> Debug for RawEventDetails<Hash>

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

Formats the value using the given formatter.

impl<Hash: Decode + Encode> Decode for RawEventDetails<Hash>

where Vec<Hash>: 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<Hash: Decode + Encode> Encode for RawEventDetails<Hash>

where Vec<Hash>: 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<Hash: Encode + Decode> From<EventDetails<Hash>> for RawEventDetails<Hash>

fn from(val: EventDetails<Hash>) -> Self

Converts to this type from the input type.

impl<Hash: PartialEq + Decode + Encode> PartialEq for RawEventDetails<Hash>

fn eq(&self, other: &RawEventDetails<Hash>) -> 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<Hash: Decode + Encode> EncodeLike for RawEventDetails<Hash>

where Vec<Hash>: Encode,

impl<Hash: Decode + Encode> StructuralPartialEq for RawEventDetails<Hash>