feat: Rebrand Polkadot/Substrate references to PezkuwiChain

This commit systematically rebrands various references from Parity Technologies'
Polkadot/Substrate ecosystem to PezkuwiChain within the kurdistan-sdk.

Key changes include:
- Updated external repository URLs (zombienet-sdk, parity-db, parity-scale-codec, wasm-instrument) to point to pezkuwichain forks.
- Modified internal documentation and code comments to reflect PezkuwiChain naming and structure.
- Replaced direct references to  with  or specific paths within the  for XCM, Pezkuwi, and other modules.
- Cleaned up deprecated  issue and PR references in various  and  files, particularly in  and  modules.
- Adjusted image and logo URLs in documentation to point to PezkuwiChain assets.
- Removed or rephrased comments related to external Polkadot/Substrate PRs and issues.

This is a significant step towards fully customizing the SDK for the PezkuwiChain ecosystem.

bizinikiwi/primitives/externalities/src/extensions.rs

@@ -0,0 +1,370 @@
+// This file is part of Bizinikiwi.
+
+// Copyright (C) Parity Technologies (UK) Ltd.
+// SPDX-License-Identifier: Apache-2.0
+
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// 	http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+//! Externalities extensions storage.
+//!
+//! Externalities support to register a wide variety custom extensions. The [`Extensions`] provides
+//! some convenience functionality to store and retrieve these extensions.
+//!
+//! It is required that each extension implements the [`Extension`] trait.
+
+use crate::Error;
+use alloc::{
+	boxed::Box,
+	collections::btree_map::{BTreeMap, Entry},
+};
+use core::{
+	any::{Any, TypeId},
+	ops::DerefMut,
+};
+
+/// Informs [`Extension`] about what type of transaction is started, committed or rolled back.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum TransactionType {
+	/// A transaction started by the host.
+	Host,
+	/// A transaction started by the runtime.
+	Runtime,
+}
+
+impl TransactionType {
+	/// Is `self` set to [`Self::Host`].
+	pub fn is_host(self) -> bool {
+		matches!(self, Self::Host)
+	}
+
+	/// Is `self` set to [`Self::Runtime`].
+	pub fn is_runtime(self) -> bool {
+		matches!(self, Self::Runtime)
+	}
+}
+
+/// Marker trait for types that should be registered as [`Externalities`](crate::Externalities)
+/// extension.
+///
+/// As extensions are stored as `Box<Any>`, this trait should give more confidence that the correct
+/// type is registered and requested.
+pub trait Extension: Send + 'static {
+	/// Return the extension as `&mut dyn Any`.
+	///
+	/// This is a trick to make the trait type castable into an [`Any`].
+	fn as_mut_any(&mut self) -> &mut dyn Any;
+
+	/// Get the [`TypeId`] of this `Extension`.
+	fn type_id(&self) -> TypeId;
+
+	/// Start a transaction of type `ty`.
+	fn start_transaction(&mut self, ty: TransactionType) {
+		let _ty = ty;
+	}
+
+	/// Commit a transaction of type `ty`.
+	fn commit_transaction(&mut self, ty: TransactionType) {
+		let _ty = ty;
+	}
+
+	/// Rollback a transaction of type `ty`.
+	fn rollback_transaction(&mut self, ty: TransactionType) {
+		let _ty = ty;
+	}
+}
+
+impl Extension for Box<dyn Extension> {
+	fn as_mut_any(&mut self) -> &mut dyn Any {
+		(**self).as_mut_any()
+	}
+
+	fn type_id(&self) -> TypeId {
+		(**self).type_id()
+	}
+
+	fn start_transaction(&mut self, ty: TransactionType) {
+		(**self).start_transaction(ty);
+	}
+
+	fn commit_transaction(&mut self, ty: TransactionType) {
+		(**self).commit_transaction(ty);
+	}
+
+	fn rollback_transaction(&mut self, ty: TransactionType) {
+		(**self).rollback_transaction(ty);
+	}
+}
+
+/// Macro for declaring an extension that usable with [`Extensions`].
+///
+/// The extension will be an unit wrapper struct that implements [`Extension`], `Deref` and
+/// `DerefMut`. The wrapped type is given by the user.
+///
+/// # Example
+/// ```
+/// # use pezsp_externalities::decl_extension;
+/// decl_extension! {
+///     /// Some test extension
+///     struct TestExt(String);
+/// }
+/// ```
+///
+/// The [`Extension`] trait provides hooks that are called when starting, committing or rolling back
+/// a transaction. These can be implemented with the macro as well:
+/// ```
+/// # use pezsp_externalities::{decl_extension, TransactionType};
+/// decl_extension! {
+///     /// Some test extension
+///     struct TestExtWithCallback(String);
+///
+///     impl TestExtWithCallback {
+///         fn start_transaction(&mut self, ty: TransactionType) {
+///             // do something cool
+///         }
+///
+///         // The other methods `commit_transaction` and `rollback_transaction` can also
+///         // be implemented in the same way.
+///     }
+/// }
+/// ```
+#[macro_export]
+macro_rules! decl_extension {
+	(
+		$( #[ $attr:meta ] )*
+		$vis:vis struct $ext_name:ident ($inner:ty);
+		$(
+			impl $ext_name_impl:ident {
+				$(
+					$impls:tt
+				)*
+			}
+		)*
+	) => {
+		$( #[ $attr ] )*
+		$vis struct $ext_name (pub $inner);
+
+		impl $crate::Extension for $ext_name {
+			fn as_mut_any(&mut self) -> &mut dyn core::any::Any {
+				self
+			}
+
+			fn type_id(&self) -> core::any::TypeId {
+				core::any::Any::type_id(self)
+			}
+
+			$(
+				$(
+					$impls
+				)*
+			)*
+		}
+
+		impl core::ops::Deref for $ext_name {
+			type Target = $inner;
+
+			fn deref(&self) -> &Self::Target {
+				&self.0
+			}
+		}
+
+		impl core::ops::DerefMut for $ext_name {
+			fn deref_mut(&mut self) -> &mut Self::Target {
+				&mut self.0
+			}
+		}
+
+		impl From<$inner> for $ext_name {
+			fn from(inner: $inner) -> Self {
+				Self(inner)
+			}
+ 		}
+	};
+	(
+		$( #[ $attr:meta ] )*
+		$vis:vis struct $ext_name:ident;
+	) => {
+		$( #[ $attr ] )*
+		$vis struct $ext_name;
+
+		impl $crate::Extension for $ext_name {
+			fn as_mut_any(&mut self) -> &mut dyn core::any::Any {
+				self
+			}
+
+			fn type_id(&self) -> core::any::TypeId {
+				core::any::Any::type_id(self)
+			}
+		}
+	}
+}
+
+/// Something that provides access to the [`Extensions`] store.
+///
+/// This is a super trait of the [`Externalities`](crate::Externalities).
+pub trait ExtensionStore {
+	/// Tries to find a registered extension by the given `type_id` and returns it as a `&mut dyn
+	/// Any`.
+	///
+	/// It is advised to use [`ExternalitiesExt::extension`](crate::ExternalitiesExt::extension)
+	/// instead of this function to get type system support and automatic type downcasting.
+	fn extension_by_type_id(&mut self, type_id: TypeId) -> Option<&mut dyn Any>;
+
+	/// Register extension `extension` with specified `type_id`.
+	///
+	/// It should return error if extension is already registered.
+	fn register_extension_with_type_id(
+		&mut self,
+		type_id: TypeId,
+		extension: Box<dyn Extension>,
+	) -> Result<(), Error>;
+
+	/// Deregister extension with specified 'type_id' and drop it.
+	///
+	/// It should return error if extension is not registered.
+	fn deregister_extension_by_type_id(&mut self, type_id: TypeId) -> Result<(), Error>;
+}
+
+/// Stores extensions that should be made available through the externalities.
+#[derive(Default)]
+pub struct Extensions {
+	extensions: BTreeMap<TypeId, Box<dyn Extension>>,
+}
+
+impl core::fmt::Debug for Extensions {
+	fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+		write!(f, "Extensions: ({})", self.extensions.len())
+	}
+}
+
+impl Extensions {
+	/// Create new instance of `Self`.
+	pub fn new() -> Self {
+		Self::default()
+	}
+
+	/// Register the given extension.
+	pub fn register<E: Extension>(&mut self, ext: E) {
+		let type_id = ext.type_id();
+		self.extensions.insert(type_id, Box::new(ext));
+	}
+
+	/// Register extension `extension` using the given `type_id`.
+	pub fn register_with_type_id(
+		&mut self,
+		type_id: TypeId,
+		extension: Box<dyn Extension>,
+	) -> Result<(), Error> {
+		match self.extensions.entry(type_id) {
+			Entry::Vacant(vacant) => {
+				vacant.insert(extension);
+				Ok(())
+			},
+			Entry::Occupied(_) => Err(Error::ExtensionAlreadyRegistered),
+		}
+	}
+
+	/// Return a mutable reference to the requested extension.
+	pub fn get_mut(&mut self, ext_type_id: TypeId) -> Option<&mut dyn Any> {
+		self.extensions
+			.get_mut(&ext_type_id)
+			.map(DerefMut::deref_mut)
+			.map(Extension::as_mut_any)
+	}
+
+	/// Deregister extension for the given `type_id`.
+	///
+	/// Returns `true` when the extension was registered.
+	pub fn deregister(&mut self, type_id: TypeId) -> bool {
+		self.extensions.remove(&type_id).is_some()
+	}
+
+	/// Returns a mutable iterator over all extensions.
+	pub fn iter_mut(&mut self) -> impl Iterator<Item = (&TypeId, &mut Box<dyn Extension>)> {
+		self.extensions.iter_mut()
+	}
+
+	/// Merge `other` into `self`.
+	///
+	/// If both contain the same extension, the extension instance of `other` will overwrite the
+	/// instance found in `self`.
+	pub fn merge(&mut self, other: Self) {
+		self.extensions.extend(other.extensions);
+	}
+
+	/// Start a transaction of type `ty`.
+	pub fn start_transaction(&mut self, ty: TransactionType) {
+		self.extensions.values_mut().for_each(|e| e.start_transaction(ty));
+	}
+
+	/// Commit a transaction of type `ty`.
+	pub fn commit_transaction(&mut self, ty: TransactionType) {
+		self.extensions.values_mut().for_each(|e| e.commit_transaction(ty));
+	}
+
+	/// Rollback a transaction of type `ty`.
+	pub fn rollback_transaction(&mut self, ty: TransactionType) {
+		self.extensions.values_mut().for_each(|e| e.rollback_transaction(ty));
+	}
+}
+
+impl Extend<Extensions> for Extensions {
+	fn extend<T: IntoIterator<Item = Extensions>>(&mut self, iter: T) {
+		iter.into_iter()
+			.for_each(|ext| self.extensions.extend(ext.extensions.into_iter()));
+	}
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+
+	decl_extension! {
+		struct DummyExt(u32);
+	}
+	decl_extension! {
+		struct DummyExt2(u32);
+	}
+
+	#[test]
+	fn register_and_retrieve_extension() {
+		let mut exts = Extensions::new();
+		exts.register(DummyExt(1));
+		exts.register(DummyExt2(2));
+
+		let ext = exts.get_mut(TypeId::of::<DummyExt>()).expect("Extension is registered");
+		let ext_ty = ext.downcast_mut::<DummyExt>().expect("Downcasting works");
+
+		assert_eq!(ext_ty.0, 1);
+	}
+
+	#[test]
+	fn register_box_extension() {
+		let mut exts = Extensions::new();
+		let box1: Box<dyn Extension> = Box::new(DummyExt(1));
+		let box2: Box<dyn Extension> = Box::new(DummyExt2(2));
+		exts.register(box1);
+		exts.register(box2);
+
+		{
+			let ext = exts.get_mut(TypeId::of::<DummyExt>()).expect("Extension 1 is registered");
+			let ext_ty = ext.downcast_mut::<DummyExt>().expect("Downcasting works for Extension 1");
+			assert_eq!(ext_ty.0, 1);
+		}
+		{
+			let ext2 = exts.get_mut(TypeId::of::<DummyExt2>()).expect("Extension 2 is registered");
+			let ext_ty2 =
+				ext2.downcast_mut::<DummyExt2>().expect("Downcasting works for Extension 2");
+			assert_eq!(ext_ty2.0, 2);
+		}
+	}
+}

bizinikiwi/primitives/externalities/src/lib.rs

@@ -0,0 +1,342 @@
+// This file is part of Bizinikiwi.
+
+// Copyright (C) Parity Technologies (UK) Ltd.
+// SPDX-License-Identifier: Apache-2.0
+
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// 	http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#![cfg_attr(not(feature = "std"), no_std)]
+
+//! Bizinikiwi externalities abstraction
+//!
+//! The externalities mainly provide access to storage and to registered extensions. Extensions
+//! are for example the keystore or the offchain externalities. These externalities are used to
+//! access the node from the runtime via the runtime interfaces.
+//!
+//! This crate exposes the main [`Externalities`] trait.
+
+extern crate alloc;
+
+use alloc::{boxed::Box, vec::Vec};
+use core::any::{Any, TypeId};
+
+use pezsp_storage::{ChildInfo, StateVersion, TrackedStorageKey};
+
+pub use extensions::{Extension, ExtensionStore, Extensions, TransactionType};
+pub use scope_limited::{set_and_run_with_externalities, with_externalities};
+
+mod extensions;
+mod scope_limited;
+
+/// Externalities error.
+#[derive(Debug)]
+pub enum Error {
+	/// Same extension cannot be registered twice.
+	ExtensionAlreadyRegistered,
+	/// Extensions are not supported.
+	ExtensionsAreNotSupported,
+	/// Extension `TypeId` is not registered.
+	ExtensionIsNotRegistered(TypeId),
+	/// Failed to update storage,
+	StorageUpdateFailed(&'static str),
+}
+
+/// Results concerning an operation to remove many keys.
+#[derive(codec::Encode, codec::Decode)]
+#[must_use]
+pub struct MultiRemovalResults {
+	/// A continuation cursor which, if `Some` must be provided to the subsequent removal call.
+	/// If `None` then all removals are complete and no further calls are needed.
+	pub maybe_cursor: Option<Vec<u8>>,
+	/// The number of items removed from the backend database.
+	pub backend: u32,
+	/// The number of unique keys removed, taking into account both the backend and the overlay.
+	pub unique: u32,
+	/// The number of iterations (each requiring a storage seek/read) which were done.
+	pub loops: u32,
+}
+
+impl MultiRemovalResults {
+	/// Deconstruct into the internal components.
+	///
+	/// Returns `(maybe_cursor, backend, unique, loops)`.
+	pub fn deconstruct(self) -> (Option<Vec<u8>>, u32, u32, u32) {
+		(self.maybe_cursor, self.backend, self.unique, self.loops)
+	}
+}
+
+/// The Bizinikiwi externalities.
+///
+/// Provides access to the storage and to other registered extensions.
+pub trait Externalities: ExtensionStore {
+	/// Write a key value pair to the offchain storage database.
+	fn set_offchain_storage(&mut self, key: &[u8], value: Option<&[u8]>);
+
+	/// Read runtime storage.
+	fn storage(&mut self, key: &[u8]) -> Option<Vec<u8>>;
+
+	/// Get storage value hash.
+	///
+	/// This may be optimized for large values.
+	fn storage_hash(&mut self, key: &[u8]) -> Option<Vec<u8>>;
+
+	/// Get child storage value hash.
+	///
+	/// This may be optimized for large values.
+	///
+	/// Returns an `Option` that holds the SCALE encoded hash.
+	fn child_storage_hash(&mut self, child_info: &ChildInfo, key: &[u8]) -> Option<Vec<u8>>;
+
+	/// Read child runtime storage.
+	///
+	/// Returns an `Option` that holds the SCALE encoded hash.
+	fn child_storage(&mut self, child_info: &ChildInfo, key: &[u8]) -> Option<Vec<u8>>;
+
+	/// Set storage entry `key` of current contract being called (effective immediately).
+	fn set_storage(&mut self, key: Vec<u8>, value: Vec<u8>) {
+		self.place_storage(key, Some(value));
+	}
+
+	/// Set child storage entry `key` of current contract being called (effective immediately).
+	fn set_child_storage(&mut self, child_info: &ChildInfo, key: Vec<u8>, value: Vec<u8>) {
+		self.place_child_storage(child_info, key, Some(value))
+	}
+
+	/// Clear a storage entry (`key`) of current contract being called (effective immediately).
+	fn clear_storage(&mut self, key: &[u8]) {
+		self.place_storage(key.to_vec(), None);
+	}
+
+	/// Clear a child storage entry (`key`) of current contract being called (effective
+	/// immediately).
+	fn clear_child_storage(&mut self, child_info: &ChildInfo, key: &[u8]) {
+		self.place_child_storage(child_info, key.to_vec(), None)
+	}
+
+	/// Whether a storage entry exists.
+	fn exists_storage(&mut self, key: &[u8]) -> bool {
+		self.storage(key).is_some()
+	}
+
+	/// Whether a child storage entry exists.
+	fn exists_child_storage(&mut self, child_info: &ChildInfo, key: &[u8]) -> bool {
+		self.child_storage(child_info, key).is_some()
+	}
+
+	/// Returns the key immediately following the given key, if it exists.
+	fn next_storage_key(&mut self, key: &[u8]) -> Option<Vec<u8>>;
+
+	/// Returns the key immediately following the given key, if it exists, in child storage.
+	fn next_child_storage_key(&mut self, child_info: &ChildInfo, key: &[u8]) -> Option<Vec<u8>>;
+
+	/// Clear an entire child storage.
+	///
+	/// Deletes all keys from the overlay and up to `maybe_limit` keys from the backend. No
+	/// limit is applied if `maybe_limit` is `None`. Returns the cursor for the next call as `Some`
+	/// if the child trie deletion operation is incomplete. In this case, it should be passed into
+	/// the next call to avoid unaccounted iterations on the backend. Returns also the the number
+	/// of keys that were removed from the backend, the number of unique keys removed in total
+	/// (including from the overlay) and the number of backend iterations done.
+	///
+	/// As long as `maybe_cursor` is passed from the result of the previous call, then the number of
+	/// iterations done will only ever be one more than the number of keys removed.
+	///
+	/// # Note
+	///
+	/// An implementation is free to delete more keys than the specified limit as long as
+	/// it is able to do that in constant time.
+	fn kill_child_storage(
+		&mut self,
+		child_info: &ChildInfo,
+		maybe_limit: Option<u32>,
+		maybe_cursor: Option<&[u8]>,
+	) -> MultiRemovalResults;
+
+	/// Clear storage entries which keys are start with the given prefix.
+	///
+	/// `maybe_limit`, `maybe_cursor` and result works as for `kill_child_storage`.
+	fn clear_prefix(
+		&mut self,
+		prefix: &[u8],
+		maybe_limit: Option<u32>,
+		maybe_cursor: Option<&[u8]>,
+	) -> MultiRemovalResults;
+
+	/// Clear child storage entries which keys are start with the given prefix.
+	///
+	/// `maybe_limit`, `maybe_cursor` and result works as for `kill_child_storage`.
+	fn clear_child_prefix(
+		&mut self,
+		child_info: &ChildInfo,
+		prefix: &[u8],
+		maybe_limit: Option<u32>,
+		maybe_cursor: Option<&[u8]>,
+	) -> MultiRemovalResults;
+
+	/// Set or clear a storage entry (`key`) of current contract being called (effective
+	/// immediately).
+	fn place_storage(&mut self, key: Vec<u8>, value: Option<Vec<u8>>);
+
+	/// Set or clear a child storage entry.
+	fn place_child_storage(&mut self, child_info: &ChildInfo, key: Vec<u8>, value: Option<Vec<u8>>);
+
+	/// Get the trie root of the current storage map.
+	///
+	/// This will also update all child storage keys in the top-level storage map.
+	///
+	/// The returned hash is defined by the `Block` and is SCALE encoded.
+	fn storage_root(&mut self, state_version: StateVersion) -> Vec<u8>;
+
+	/// Get the trie root of a child storage map.
+	///
+	/// This will also update the value of the child storage keys in the top-level storage map.
+	///
+	/// If the storage root equals the default hash as defined by the trie, the key in the top-level
+	/// storage map will be removed.
+	fn child_storage_root(
+		&mut self,
+		child_info: &ChildInfo,
+		state_version: StateVersion,
+	) -> Vec<u8>;
+
+	/// Append storage item.
+	///
+	/// This assumes specific format of the storage item. Also there is no way to undo this
+	/// operation.
+	fn storage_append(&mut self, key: Vec<u8>, value: Vec<u8>);
+
+	/// Start a new nested transaction.
+	///
+	/// This allows to either commit or roll back all changes made after this call to the
+	/// top changes or the default child changes. For every transaction there cam be a
+	/// matching call to either `storage_rollback_transaction` or `storage_commit_transaction`.
+	/// Any transactions that are still open after returning from runtime are committed
+	/// automatically.
+	///
+	/// Changes made without any open transaction are committed immediately.
+	fn storage_start_transaction(&mut self);
+
+	/// Rollback the last transaction started by `storage_start_transaction`.
+	///
+	/// Any changes made during that storage transaction are discarded. Returns an error when
+	/// no transaction is open that can be closed.
+	fn storage_rollback_transaction(&mut self) -> Result<(), ()>;
+
+	/// Commit the last transaction started by `storage_start_transaction`.
+	///
+	/// Any changes made during that storage transaction are committed. Returns an error when
+	/// no transaction is open that can be closed.
+	fn storage_commit_transaction(&mut self) -> Result<(), ()>;
+
+	/// Index specified transaction slice and store it.
+	fn storage_index_transaction(&mut self, _index: u32, _hash: &[u8], _size: u32) {
+		unimplemented!("storage_index_transaction");
+	}
+
+	/// Renew existing piece of transaction storage.
+	fn storage_renew_transaction_index(&mut self, _index: u32, _hash: &[u8]) {
+		unimplemented!("storage_renew_transaction_index");
+	}
+
+	/// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+	/// Benchmarking related functionality and shouldn't be used anywhere else!
+	/// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+	///
+	/// Wipes all changes from caches and the database.
+	///
+	/// The state will be reset to genesis.
+	fn wipe(&mut self);
+
+	/// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+	/// Benchmarking related functionality and shouldn't be used anywhere else!
+	/// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+	///
+	/// Commits all changes to the database and clears all caches.
+	fn commit(&mut self);
+
+	/// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+	/// Benchmarking related functionality and shouldn't be used anywhere else!
+	/// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+	///
+	/// Gets the current read/write count for the benchmarking process.
+	fn read_write_count(&self) -> (u32, u32, u32, u32);
+
+	/// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+	/// Benchmarking related functionality and shouldn't be used anywhere else!
+	/// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+	///
+	/// Resets read/write count for the benchmarking process.
+	fn reset_read_write_count(&mut self);
+
+	/// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+	/// Benchmarking related functionality and shouldn't be used anywhere else!
+	/// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+	///
+	/// Gets the current DB tracking whitelist.
+	fn get_whitelist(&self) -> Vec<TrackedStorageKey>;
+
+	/// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+	/// Benchmarking related functionality and shouldn't be used anywhere else!
+	/// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+	///
+	/// Adds new storage keys to the DB tracking whitelist.
+	fn set_whitelist(&mut self, new: Vec<TrackedStorageKey>);
+
+	/// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+	/// Benchmarking related functionality and shouldn't be used anywhere else!
+	/// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+	///
+	/// Returns estimated proof size for the state queries so far.
+	/// Proof is reset on commit and wipe.
+	fn proof_size(&self) -> Option<u32> {
+		None
+	}
+
+	/// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+	/// Benchmarking related functionality and shouldn't be used anywhere else!
+	/// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+	///
+	/// Get all the keys that have been read or written to during the benchmark.
+	fn get_read_and_written_keys(&self) -> Vec<(Vec<u8>, u32, u32, bool)>;
+}
+
+/// Extension for the [`Externalities`] trait.
+pub trait ExternalitiesExt {
+	/// Tries to find a registered extension and returns a mutable reference.
+	fn extension<T: Any + Extension>(&mut self) -> Option<&mut T>;
+
+	/// Register extension `ext`.
+	///
+	/// Should return error if extension is already registered or extensions are not supported.
+	fn register_extension<T: Extension>(&mut self, ext: T) -> Result<(), Error>;
+
+	/// Deregister and drop extension of `T` type.
+	///
+	/// Should return error if extension of type `T` is not registered or
+	/// extensions are not supported.
+	fn deregister_extension<T: Extension>(&mut self) -> Result<(), Error>;
+}
+
+impl ExternalitiesExt for &mut dyn Externalities {
+	fn extension<T: Any + Extension>(&mut self) -> Option<&mut T> {
+		self.extension_by_type_id(TypeId::of::<T>()).and_then(<dyn Any>::downcast_mut)
+	}
+
+	fn register_extension<T: Extension>(&mut self, ext: T) -> Result<(), Error> {
+		self.register_extension_with_type_id(TypeId::of::<T>(), Box::new(ext))
+	}
+
+	fn deregister_extension<T: Extension>(&mut self) -> Result<(), Error> {
+		self.deregister_extension_by_type_id(TypeId::of::<T>())
+	}
+}

bizinikiwi/primitives/externalities/src/scope_limited.rs

@@ -0,0 +1,39 @@
+// This file is part of Bizinikiwi.
+
+// Copyright (C) Parity Technologies (UK) Ltd.
+// SPDX-License-Identifier: Apache-2.0
+
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// 	http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+//! Stores the externalities in an `environmental` value to make it scope limited available.
+
+use crate::Externalities;
+
+environmental::environmental!(ext: trait Externalities);
+
+/// Set the given externalities while executing the given closure. To get access to the
+/// externalities while executing the given closure [`with_externalities`] grants access to them.
+/// The externalities are only set for the same thread this function was called from.
+pub fn set_and_run_with_externalities<F, R>(ext: &mut dyn Externalities, f: F) -> R
+where
+	F: FnOnce() -> R,
+{
+	ext::using(ext, f)
+}
+
+/// Execute the given closure with the currently set externalities.
+///
+/// Returns `None` if no externalities are set or `Some(_)` with the result of the closure.
+pub fn with_externalities<F: FnOnce(&mut dyn Externalities) -> R, R>(f: F) -> Option<R> {
+	ext::with(f)
+}