Enum GovernedMapInherentDataProvider

pub enum GovernedMapInherentDataProvider {
    Inert,
    ActiveV1 {
        data: GovernedMapInherentDataV1,
    },
}

Inherent data provider providing the list of Governed Map changes that occurred since previous observation.

Variants

Inert

Inactive variant that will not provide any data and will not raise any errors.

ActiveV1

Active variant that will provide data.

Fields

data: GovernedMapInherentDataV1

Inherent data provided by this IDP

Implementations

impl GovernedMapInherentDataProvider

pub async fn new<T, Block>( client: &T, parent_hash: Block::Hash, mc_hash: McBlockHash, parent_mc_hash: Option<McBlockHash>, data_source: &(dyn GovernedMapDataSource + Send + Sync), ) -> Result<Self, InherentProviderCreationError>

where Block: Block, T: ProvideRuntimeApi<Block> + Send + Sync, T::Api: GovernedMapIDPApi<Block>,

Creates a new GovernedMapInherentDataProvider with reference to the passed Cardano block hash.

This function is version aware and will return:

• an inert IDP if the pallet is not present in the runtime
• an inert IDP if the pallet does not have main chain scripts configured yet
• an IDP compatible with the pallet version signalled through the runtime API

Parameters:

• client: runtime client capable of providing GovernedMapIDPApi runtime API
• parent_hash: parent hash of the current block
• mc_hash: Cardano block hash referenced by the current block
• parent_mc_hash: Cardano block hash referenced by the parent of the current block
• data_source: data source implementing GovernedMapDataSource

Trait Implementations

impl Debug for GovernedMapInherentDataProvider

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

Formats the value using the given formatter.

impl InherentDataProvider for GovernedMapInherentDataProvider

fn provide_inherent_data<'life0, 'life1, 'async_trait>( &'life0 self, inherent_data: &'life1 mut InherentData, ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Provide inherent data that should be included in a block.

fn try_handle_error<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, identifier: &'life1 InherentIdentifier, error: &'life2 [u8], ) -> Pin<Box<dyn Future<Output = Option<Result<(), Error>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Convert the given encoded error to a string.

fn create_inherent_data<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<InherentData, Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, Self: 'async_trait,

Convenience function for creating [InherentData].

impl PartialEq for GovernedMapInherentDataProvider

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