Skip to main content

soil_client/client_api/
execution_extensions.rs

1// This file is part of Soil.
2
3// Copyright (C) Soil contributors.
4// Copyright (C) Parity Technologies (UK) Ltd.
5// SPDX-License-Identifier: GPL-3.0-or-later WITH Classpath-exception-2.0
6
7//! Execution extensions for runtime calls.
8//!
9//! This module is responsible for defining the execution
10//! strategy for the runtime calls and provide the right `Externalities`
11//! extensions to support APIs for particular execution context & capabilities.
12
13use parking_lot::RwLock;
14use std::{marker::PhantomData, sync::Arc};
15use subsoil::core::traits::{ReadRuntimeVersion, ReadRuntimeVersionExt};
16use subsoil::externalities::{Extension, Extensions};
17use subsoil::runtime::traits::{Block as BlockT, NumberFor};
18
19/// Generate the starting set of [`Extensions`].
20///
21/// These [`Extensions`] are passed to the environment a runtime is executed in.
22pub trait ExtensionsFactory<Block: BlockT>: Send + Sync {
23	/// Create [`Extensions`] for the given input.
24	///
25	/// - `block_hash`: The hash of the block in the context that extensions will be used.
26	/// - `block_number`: The number of the block in the context that extensions will be used.
27	fn extensions_for(&self, block_hash: Block::Hash, block_number: NumberFor<Block>)
28		-> Extensions;
29}
30
31impl<Block: BlockT> ExtensionsFactory<Block> for () {
32	fn extensions_for(&self, _: Block::Hash, _: NumberFor<Block>) -> Extensions {
33		Extensions::new()
34	}
35}
36
37impl<Block: BlockT, T: ExtensionsFactory<Block>> ExtensionsFactory<Block> for Vec<T> {
38	fn extensions_for(
39		&self,
40		block_hash: Block::Hash,
41		block_number: NumberFor<Block>,
42	) -> Extensions {
43		let mut exts = Extensions::new();
44		exts.extend(self.iter().map(|e| e.extensions_for(block_hash, block_number)));
45		exts
46	}
47}
48
49/// An [`ExtensionsFactory`] that registers an [`Extension`] before a certain block.
50pub struct ExtensionBeforeBlock<Block: BlockT, Ext> {
51	before: NumberFor<Block>,
52	_marker: PhantomData<fn(Ext) -> Ext>,
53}
54
55impl<Block: BlockT, Ext> ExtensionBeforeBlock<Block, Ext> {
56	/// Create the extension factory.
57	///
58	/// - `before`: The block number until the extension should be registered.
59	pub fn new(before: NumberFor<Block>) -> Self {
60		Self { before, _marker: PhantomData }
61	}
62}
63
64impl<Block: BlockT, Ext: Default + Extension> ExtensionsFactory<Block>
65	for ExtensionBeforeBlock<Block, Ext>
66{
67	fn extensions_for(&self, _: Block::Hash, block_number: NumberFor<Block>) -> Extensions {
68		let mut exts = Extensions::new();
69
70		if block_number < self.before {
71			exts.register(Ext::default());
72		}
73
74		exts
75	}
76}
77
78/// A producer of execution extensions for offchain calls.
79///
80/// This crate aggregates extensions available for the offchain calls
81/// and is responsible for producing a correct `Extensions` object.
82pub struct ExecutionExtensions<Block: BlockT> {
83	extensions_factory: RwLock<Box<dyn ExtensionsFactory<Block>>>,
84	read_runtime_version: Arc<dyn ReadRuntimeVersion>,
85}
86
87impl<Block: BlockT> ExecutionExtensions<Block> {
88	/// Create new `ExecutionExtensions` given an `extensions_factory`.
89	pub fn new(
90		extensions_factory: Option<Box<dyn ExtensionsFactory<Block>>>,
91		read_runtime_version: Arc<dyn ReadRuntimeVersion>,
92	) -> Self {
93		Self {
94			extensions_factory: extensions_factory
95				.map(RwLock::new)
96				.unwrap_or_else(|| RwLock::new(Box::new(()))),
97			read_runtime_version,
98		}
99	}
100
101	/// Set the new extensions_factory
102	pub fn set_extensions_factory(&self, maker: impl ExtensionsFactory<Block> + 'static) {
103		*self.extensions_factory.write() = Box::new(maker);
104	}
105
106	/// Produces default extensions based on the input parameters.
107	pub fn extensions(
108		&self,
109		block_hash: Block::Hash,
110		block_number: NumberFor<Block>,
111	) -> Extensions {
112		let mut extensions =
113			self.extensions_factory.read().extensions_for(block_hash, block_number);
114
115		extensions.register(ReadRuntimeVersionExt::new(self.read_runtime_version.clone()));
116		extensions
117	}
118}