Struct sc_client_api::execution_extensions::ExecutionExtensions

pub struct ExecutionExtensions<Block: BlockT> { /* private fields */ }

A producer of execution extensions for offchain calls.

This crate aggregates extensions available for the offchain calls and is responsible for producing a correct Extensions object. for each call, based on required Capabilities.

Implementations

impl<Block: BlockT> ExecutionExtensions<Block>

pub fn new(
    strategies: ExecutionStrategies,
    keystore: Option<SyncCryptoStorePtr>,
    offchain_db: Option<Box<dyn DbExternalitiesFactory>>
) -> Self

Create new ExecutionExtensions given a keystore and ExecutionStrategies.

pub fn strategies(&self) -> &ExecutionStrategies

Get a reference to the execution strategies.

pub fn set_extensions_factory(
    &self,
    maker: impl ExtensionsFactory<Block> + 'static
)

Set the new extensions_factory

pub fn register_transaction_pool<T>(&self, pool: &Arc<T>)where
    T: OffchainSubmitTransaction<Block> + 'static,

Register transaction pool extension.

pub fn extensions(
    &self,
    block_hash: Block::Hash,
    block_number: NumberFor<Block>,
    context: ExecutionContext
) -> Extensions

Based on the execution context and capabilities it produces the extensions object to support desired set of APIs.

Examples found in repository

src/execution_extensions.rs (line 296)

	pub fn manager_and_extensions<E: std::fmt::Debug>(
		&self,
		block_hash: Block::Hash,
		block_number: NumberFor<Block>,
		context: ExecutionContext,
	) -> (ExecutionManager<DefaultHandler<E>>, Extensions) {
		let manager = match context {
			ExecutionContext::BlockConstruction => self.strategies.block_construction.get_manager(),
			ExecutionContext::Syncing => self.strategies.syncing.get_manager(),
			ExecutionContext::Importing => self.strategies.importing.get_manager(),
			ExecutionContext::OffchainCall(Some((_, capabilities))) if capabilities.is_all() =>
				self.strategies.offchain_worker.get_manager(),
			ExecutionContext::OffchainCall(_) => self.strategies.other.get_manager(),
		};

		(manager, self.extensions(block_hash, block_number, context))
	}

pub fn manager_and_extensions<E: Debug>(
    &self,
    block_hash: Block::Hash,
    block_number: NumberFor<Block>,
    context: ExecutionContext
) -> (ExecutionManager<DefaultHandler<E>>, Extensions)

Create ExecutionManager and Extensions for given offchain call.

Based on the execution context and capabilities it produces the right manager and extensions object to support desired set of APIs.

Trait Implementations

impl<Block: BlockT> Default for ExecutionExtensions<Block>

fn default() -> Self

Returns the “default value” for a type.