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/pezframe/benchmarking/pov/Cargo.toml

@@ -0,0 +1,48 @@
+[package]
+name = "pezframe-benchmarking-pezpallet-pov"
+version = "18.0.0"
+authors.workspace = true
+edition.workspace = true
+license = "Apache-2.0"
+homepage.workspace = true
+repository.workspace = true
+description = "Pallet for testing FRAME PoV benchmarking"
+
+[lints]
+workspace = true
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+codec = { workspace = true }
+pezframe-benchmarking = { workspace = true }
+pezframe-support = { workspace = true }
+pezframe-system = { workspace = true }
+scale-info = { features = ["derive"], workspace = true }
+pezsp-io = { workspace = true }
+pezsp-runtime = { workspace = true }
+
+[features]
+default = ["std"]
+std = [
+	"codec/std",
+	"pezframe-benchmarking/std",
+	"pezframe-support/std",
+	"pezframe-system/std",
+	"scale-info/std",
+	"pezsp-io/std",
+	"pezsp-runtime/std",
+]
+runtime-benchmarks = [
+	"pezframe-benchmarking/runtime-benchmarks",
+	"pezframe-support/runtime-benchmarks",
+	"pezframe-system/runtime-benchmarks",
+	"pezsp-io/runtime-benchmarks",
+	"pezsp-runtime/runtime-benchmarks",
+]
+try-runtime = [
+	"pezframe-support/try-runtime",
+	"pezframe-system/try-runtime",
+	"pezsp-runtime/try-runtime",
+]

bizinikiwi/pezframe/benchmarking/pov/src/benchmarking.rs

@@ -0,0 +1,450 @@
+// 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.
+
+//! All benchmarks in this file are just for debugging the PoV calculation logic, they are unused.
+
+#![cfg(feature = "runtime-benchmarks")]
+
+use super::*;
+
+use pezframe_benchmarking::v2::*;
+use pezframe_support::traits::UnfilteredDispatchable;
+use pezframe_system::{Pallet as System, RawOrigin};
+use pezsp_runtime::traits::Hash;
+
+#[benchmarks]
+mod benchmarks {
+	use super::*;
+
+	#[benchmark]
+	fn storage_single_value_read() {
+		Value::<T>::put(123);
+
+		#[block]
+		{
+			assert_eq!(Value::<T>::get(), Some(123));
+		}
+	}
+
+	#[benchmark(pov_mode = Ignored)]
+	fn storage_single_value_ignored_read() {
+		Value::<T>::put(123);
+		#[block]
+		{
+			assert_eq!(Value::<T>::get(), Some(123));
+		}
+	}
+
+	#[benchmark(pov_mode = MaxEncodedLen {
+		Pov::Value2: Ignored
+	})]
+	fn storage_single_value_ignored_some_read() {
+		Value::<T>::put(123);
+		Value2::<T>::put(123);
+
+		#[block]
+		{
+			assert_eq!(Value::<T>::get(), Some(123));
+			assert_eq!(Value2::<T>::get(), Some(123));
+		}
+	}
+
+	#[benchmark]
+	fn storage_single_value_read_twice() {
+		Value::<T>::put(123);
+
+		#[block]
+		{
+			assert_eq!(Value::<T>::get(), Some(123));
+			assert_eq!(Value::<T>::get(), Some(123));
+		}
+	}
+
+	#[benchmark]
+	fn storage_single_value_write() {
+		#[block]
+		{
+			Value::<T>::put(123);
+		}
+
+		assert_eq!(Value::<T>::get(), Some(123));
+	}
+
+	#[benchmark]
+	fn storage_single_value_kill() {
+		Value::<T>::put(123);
+
+		#[block]
+		{
+			Value::<T>::kill();
+		}
+
+		assert!(!Value::<T>::exists());
+	}
+
+	// This benchmark and the following are testing a storage map with adjacent storage items.
+	//
+	// First a storage map is filled and a specific number of other storage items is
+	// created. Then the one value is read from the map. This demonstrates that the number of other
+	// nodes in the Trie influences the proof size. The number of inserted nodes can be interpreted
+	// as the number of `StorageMap`/`StorageValue` in the whole runtime.
+	#[benchmark(pov_mode = Measured)]
+	fn storage_1m_map_read_one_value_two_additional_layers() {
+		(0..(1 << 10)).for_each(|i| Map1M::<T>::insert(i, i));
+		// Assume there are 16-256 other storage items.
+		(0..(1u32 << 4)).for_each(|i| {
+			let k = T::Hashing::hash(&i.to_be_bytes());
+			pezframe_support::storage::unhashed::put(k.as_ref(), &i);
+		});
+
+		#[block]
+		{
+			assert_eq!(Map1M::<T>::get(1 << 9), Some(1 << 9));
+		}
+	}
+
+	#[benchmark(pov_mode = Measured)]
+	fn storage_1m_map_read_one_value_three_additional_layers() {
+		(0..(1 << 10)).for_each(|i| Map1M::<T>::insert(i, i));
+		// Assume there are 256-4096 other storage items.
+		(0..(1u32 << 8)).for_each(|i| {
+			let k = T::Hashing::hash(&i.to_be_bytes());
+			pezframe_support::storage::unhashed::put(k.as_ref(), &i);
+		});
+
+		#[block]
+		{
+			assert_eq!(Map1M::<T>::get(1 << 9), Some(1 << 9));
+		}
+	}
+
+	#[benchmark(pov_mode = Measured)]
+	fn storage_1m_map_read_one_value_four_additional_layers() {
+		(0..(1 << 10)).for_each(|i| Map1M::<T>::insert(i, i));
+		// Assume there are 4096-65536 other storage items.
+		(0..(1u32 << 12)).for_each(|i| {
+			let k = T::Hashing::hash(&i.to_be_bytes());
+			pezframe_support::storage::unhashed::put(k.as_ref(), &i);
+		});
+
+		#[block]
+		{
+			assert_eq!(Map1M::<T>::get(1 << 9), Some(1 << 9));
+		}
+	}
+
+	// Reads from both storage maps each `n` and `m` times. Should result in two linear components.
+	#[benchmark]
+	fn storage_map_read_per_component(n: Linear<0, 100>, m: Linear<0, 100>) {
+		(0..m * 10).for_each(|i| Map1M::<T>::insert(i, i));
+		(0..n * 10).for_each(|i| Map16M::<T>::insert(i, i));
+
+		#[block]
+		{
+			(0..m).for_each(|i| assert_eq!(Map1M::<T>::get(i * 10), Some(i * 10)));
+			(0..n).for_each(|i| assert_eq!(Map16M::<T>::get(i * 10), Some(i * 10)));
+		}
+	}
+
+	#[benchmark(pov_mode = MaxEncodedLen {
+		Pov::Map1M: Ignored
+	})]
+	fn storage_map_read_per_component_one_ignored(n: Linear<0, 100>, m: Linear<0, 100>) {
+		(0..m * 10).for_each(|i| Map1M::<T>::insert(i, i));
+		(0..n * 10).for_each(|i| Map16M::<T>::insert(i, i));
+
+		#[block]
+		{
+			(0..m).for_each(|i| assert_eq!(Map1M::<T>::get(i * 10), Some(i * 10)));
+			(0..n).for_each(|i| assert_eq!(Map16M::<T>::get(i * 10), Some(i * 10)));
+		}
+	}
+
+	// Reads the same value from a storage map. Should not result in a component.
+	#[benchmark]
+	fn storage_1m_map_one_entry_repeated_read(n: Linear<0, 100>) {
+		Map1M::<T>::insert(0, 0);
+
+		#[block]
+		{
+			(0..n).for_each(|_| assert_eq!(Map1M::<T>::get(0), Some(0)));
+		}
+	}
+
+	// Reads the same values from a storage map. Should result in a `1x` linear component.
+	#[benchmark]
+	fn storage_1m_map_multiple_entry_repeated_read(n: Linear<0, 100>) {
+		(0..n).for_each(|i| Map1M::<T>::insert(i, i));
+
+		#[block]
+		{
+			(0..n).for_each(|i| {
+				// Reading the same value 10 times does nothing.
+				(0..10).for_each(|_| assert_eq!(Map1M::<T>::get(i), Some(i)));
+			});
+		}
+	}
+
+	#[benchmark]
+	fn storage_1m_double_map_read_per_component(n: Linear<0, 1024>) {
+		(0..(1 << 10)).for_each(|i| DoubleMap1M::<T>::insert(i, i, i));
+
+		#[block]
+		{
+			(0..n).for_each(|i| assert_eq!(DoubleMap1M::<T>::get(i, i), Some(i)));
+		}
+	}
+
+	#[benchmark]
+	fn storage_value_bounded_read() {
+		#[block]
+		{
+			assert!(BoundedValue::<T>::get().is_none());
+		}
+	}
+
+	// Reading unbounded values will produce no mathematical worst case PoV size for this component.
+	#[benchmark]
+	fn storage_value_unbounded_read() {
+		#[block]
+		{
+			assert!(UnboundedValue::<T>::get().is_none());
+		}
+	}
+
+	#[benchmark(pov_mode = Ignored)]
+	fn storage_value_unbounded_ignored_read() {
+		#[block]
+		{
+			assert!(UnboundedValue::<T>::get().is_none());
+		}
+	}
+
+	// Same as above, but we still expect a mathematical worst case PoV size for the bounded one.
+	#[benchmark]
+	fn storage_value_bounded_and_unbounded_read() {
+		(0..1024).for_each(|i| Map1M::<T>::insert(i, i));
+		#[block]
+		{
+			assert!(UnboundedValue::<T>::get().is_none());
+			assert!(BoundedValue::<T>::get().is_none());
+		}
+	}
+
+	#[benchmark(pov_mode = Measured)]
+	fn measured_storage_value_read_linear_size(l: Linear<0, { 1 << 22 }>) {
+		let v: pezsp_runtime::BoundedVec<u8, _> = alloc::vec![0u8; l as usize].try_into().unwrap();
+		LargeValue::<T>::put(&v);
+		#[block]
+		{
+			assert!(LargeValue::<T>::get().is_some());
+		}
+	}
+
+	#[benchmark(pov_mode = MaxEncodedLen)]
+	fn mel_storage_value_read_linear_size(l: Linear<0, { 1 << 22 }>) {
+		let v: pezsp_runtime::BoundedVec<u8, _> = alloc::vec![0u8; l as usize].try_into().unwrap();
+		LargeValue::<T>::put(&v);
+		#[block]
+		{
+			assert!(LargeValue::<T>::get().is_some());
+		}
+	}
+
+	#[benchmark(pov_mode = Measured)]
+	fn measured_storage_double_value_read_linear_size(l: Linear<0, { 1 << 22 }>) {
+		let v: pezsp_runtime::BoundedVec<u8, _> = alloc::vec![0u8; l as usize].try_into().unwrap();
+		LargeValue::<T>::put(&v);
+		LargeValue2::<T>::put(&v);
+		#[block]
+		{
+			assert!(LargeValue::<T>::get().is_some());
+			assert!(LargeValue2::<T>::get().is_some());
+		}
+	}
+
+	#[benchmark(pov_mode = MaxEncodedLen)]
+	fn mel_storage_double_value_read_linear_size(l: Linear<0, { 1 << 22 }>) {
+		let v: pezsp_runtime::BoundedVec<u8, _> = alloc::vec![0u8; l as usize].try_into().unwrap();
+		LargeValue::<T>::put(&v);
+		LargeValue2::<T>::put(&v);
+		#[block]
+		{
+			assert!(LargeValue::<T>::get().is_some());
+			assert!(LargeValue2::<T>::get().is_some());
+		}
+	}
+
+	#[benchmark(pov_mode = MaxEncodedLen {
+		Pov::LargeValue2: Measured
+	})]
+	fn mel_mixed_storage_double_value_read_linear_size(l: Linear<0, { 1 << 22 }>) {
+		let v: pezsp_runtime::BoundedVec<u8, _> = alloc::vec![0u8; l as usize].try_into().unwrap();
+		LargeValue::<T>::put(&v);
+		LargeValue2::<T>::put(&v);
+		#[block]
+		{
+			assert!(LargeValue::<T>::get().is_some());
+			assert!(LargeValue2::<T>::get().is_some());
+		}
+	}
+
+	#[benchmark(pov_mode = Measured {
+		Pov::LargeValue2: MaxEncodedLen
+	})]
+	fn measured_mixed_storage_double_value_read_linear_size(l: Linear<0, { 1 << 22 }>) {
+		let v: pezsp_runtime::BoundedVec<u8, _> = alloc::vec![0u8; l as usize].try_into().unwrap();
+		LargeValue::<T>::put(&v);
+		LargeValue2::<T>::put(&v);
+		#[block]
+		{
+			assert!(LargeValue::<T>::get().is_some());
+			assert!(LargeValue2::<T>::get().is_some());
+		}
+	}
+
+	#[benchmark(pov_mode = Measured)]
+	fn storage_map_unbounded_both_measured_read(i: Linear<0, 1000>) {
+		UnboundedMap::<T>::insert(i, alloc::vec![0; i as usize]);
+		UnboundedMap2::<T>::insert(i, alloc::vec![0; i as usize]);
+		#[block]
+		{
+			assert!(UnboundedMap::<T>::get(i).is_some());
+			assert!(UnboundedMap2::<T>::get(i).is_some());
+		}
+	}
+
+	#[benchmark(pov_mode = MaxEncodedLen {
+		Pov::UnboundedMap: Measured
+	})]
+	fn storage_map_partial_unbounded_read(i: Linear<0, 1000>) {
+		Map1M::<T>::insert(i, 0);
+		UnboundedMap::<T>::insert(i, alloc::vec![0; i as usize]);
+		#[block]
+		{
+			assert!(Map1M::<T>::get(i).is_some());
+			assert!(UnboundedMap::<T>::get(i).is_some());
+		}
+	}
+
+	#[benchmark(pov_mode = MaxEncodedLen {
+		Pov::UnboundedMap: Ignored
+	})]
+	fn storage_map_partial_unbounded_ignored_read(i: Linear<0, 1000>) {
+		Map1M::<T>::insert(i, 0);
+		UnboundedMap::<T>::insert(i, alloc::vec![0; i as usize]);
+		#[block]
+		{
+			assert!(Map1M::<T>::get(i).is_some());
+			assert!(UnboundedMap::<T>::get(i).is_some());
+		}
+	}
+
+	// Emitting an event will not incur any PoV.
+	#[benchmark]
+	fn emit_event() {
+		// Emit a single event.
+		let call = Call::<T>::emit_event {};
+		#[block]
+		{
+			call.dispatch_bypass_filter(RawOrigin::Root.into()).unwrap();
+		}
+		assert_eq!(System::<T>::events().len(), 1);
+	}
+
+	// A No-OP will not incur any PoV.
+	#[benchmark]
+	fn noop() {
+		let call = Call::<T>::noop {};
+		#[block]
+		{
+			call.dispatch_bypass_filter(RawOrigin::Root.into()).unwrap();
+		}
+	}
+
+	#[benchmark]
+	fn storage_iteration() {
+		for i in 0..65000 {
+			UnboundedMapTwox::<T>::insert(i, alloc::vec![0; 64]);
+		}
+		#[block]
+		{
+			for (key, value) in UnboundedMapTwox::<T>::iter() {
+				unsafe {
+					core::ptr::read_volatile(&key);
+					core::ptr::read_volatile(value.as_ptr());
+				}
+			}
+		}
+	}
+
+	impl_benchmark_test_suite!(Pallet, super::mock::new_test_ext(), super::mock::Test,);
+}
+
+#[cfg(test)]
+mod mock {
+	use pezframe_support::derive_impl;
+	use pezsp_runtime::{testing::H256, BuildStorage};
+
+	type AccountId = u64;
+	type Nonce = u32;
+
+	type Block = pezframe_system::mocking::MockBlock<Test>;
+
+	pezframe_support::construct_runtime!(
+		pub enum Test
+		{
+			System: pezframe_system,
+			Baseline: crate,
+		}
+	);
+
+	#[derive_impl(pezframe_system::config_preludes::TestDefaultConfig)]
+	impl pezframe_system::Config for Test {
+		type BaseCallFilter = pezframe_support::traits::Everything;
+		type BlockWeights = ();
+		type BlockLength = ();
+		type DbWeight = ();
+		type RuntimeOrigin = RuntimeOrigin;
+		type Nonce = Nonce;
+		type RuntimeCall = RuntimeCall;
+		type Hash = H256;
+		type Hashing = ::pezsp_runtime::traits::BlakeTwo256;
+		type AccountId = AccountId;
+		type Lookup = pezsp_runtime::traits::IdentityLookup<Self::AccountId>;
+		type Block = Block;
+		type RuntimeEvent = RuntimeEvent;
+		type BlockHashCount = ();
+		type Version = ();
+		type PalletInfo = PalletInfo;
+		type AccountData = ();
+		type OnNewAccount = ();
+		type OnKilledAccount = ();
+		type SystemWeightInfo = ();
+		type SS58Prefix = ();
+		type OnSetCode = ();
+		type MaxConsumers = pezframe_support::traits::ConstU32<16>;
+	}
+
+	impl crate::Config for Test {
+		type RuntimeEvent = RuntimeEvent;
+	}
+
+	pub fn new_test_ext() -> pezsp_io::TestExternalities {
+		pezframe_system::GenesisConfig::<Test>::default().build_storage().unwrap().into()
+	}
+}

bizinikiwi/pezframe/benchmarking/pov/src/lib.rs

@@ -0,0 +1,138 @@
+// 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.
+
+//! End-to-end testing pallet for PoV benchmarking. Should only be deployed in a  testing runtime.
+
+#![cfg_attr(not(feature = "std"), no_std)]
+
+mod benchmarking;
+mod tests;
+mod weights;
+
+extern crate alloc;
+
+pub use pallet::*;
+
+#[pezframe_support::pallet]
+pub mod pallet {
+	use alloc::vec::Vec;
+	use pezframe_support::pezpallet_prelude::*;
+	use pezframe_system::pezpallet_prelude::*;
+
+	#[pallet::pallet]
+	pub struct Pallet<T>(_);
+
+	#[pallet::config]
+	pub trait Config: pezframe_system::Config {
+		#[allow(deprecated)]
+		type RuntimeEvent: From<Event<Self>> + IsType<<Self as pezframe_system::Config>::RuntimeEvent>;
+	}
+
+	#[pallet::storage]
+	pub(crate) type Value<T: Config> = StorageValue<Value = u32, QueryKind = OptionQuery>;
+
+	#[pallet::storage]
+	pub(crate) type Value2<T: Config> = StorageValue<Value = u32, QueryKind = OptionQuery>;
+
+	/// A value without a MEL bound.
+	#[pallet::storage]
+	#[pallet::unbounded]
+	pub(crate) type UnboundedValue<T: Config> =
+		StorageValue<Value = Vec<u8>, QueryKind = OptionQuery>;
+
+	/// A value with a MEL bound of 32 byte.
+	#[pallet::storage]
+	pub(crate) type BoundedValue<T: Config> =
+		StorageValue<Value = BoundedVec<u8, ConstU32<32>>, QueryKind = OptionQuery>;
+
+	/// 4MiB value.
+	#[pallet::storage]
+	pub(crate) type LargeValue<T: Config> =
+		StorageValue<Value = BoundedVec<u8, ConstU32<{ 1 << 22 }>>, QueryKind = OptionQuery>;
+
+	#[pallet::storage]
+	pub(crate) type LargeValue2<T: Config> =
+		StorageValue<Value = BoundedVec<u8, ConstU32<{ 1 << 22 }>>, QueryKind = OptionQuery>;
+
+	/// A map with a maximum of 1M entries.
+	#[pallet::storage]
+	pub(crate) type Map1M<T: Config> = StorageMap<
+		Hasher = Blake2_256,
+		Key = u32,
+		Value = u32,
+		QueryKind = OptionQuery,
+		MaxValues = ConstU32<1_000_000>,
+	>;
+
+	/// A map with a maximum of 16M entries.
+	#[pallet::storage]
+	pub(crate) type Map16M<T: Config> = StorageMap<
+		Hasher = Blake2_256,
+		Key = u32,
+		Value = u32,
+		QueryKind = OptionQuery,
+		MaxValues = ConstU32<16_000_000>,
+	>;
+
+	#[pallet::storage]
+	pub(crate) type DoubleMap1M<T: Config> = StorageDoubleMap<
+		Hasher1 = Blake2_256,
+		Hasher2 = Blake2_256,
+		Key1 = u32,
+		Key2 = u32,
+		Value = u32,
+		QueryKind = OptionQuery,
+		MaxValues = ConstU32<1_000_000>,
+	>;
+
+	#[pallet::storage]
+	#[pallet::unbounded]
+	pub(crate) type UnboundedMap<T: Config> =
+		StorageMap<Hasher = Blake2_256, Key = u32, Value = Vec<u32>, QueryKind = OptionQuery>;
+
+	#[pallet::storage]
+	#[pallet::unbounded]
+	pub(crate) type UnboundedMap2<T: Config> =
+		StorageMap<Hasher = Blake2_256, Key = u32, Value = Vec<u32>, QueryKind = OptionQuery>;
+
+	#[pallet::storage]
+	#[pallet::unbounded]
+	pub(crate) type UnboundedMapTwox<T: Config> =
+		StorageMap<Hasher = Twox64Concat, Key = u32, Value = Vec<u32>, QueryKind = OptionQuery>;
+
+	#[pallet::event]
+	#[pallet::generate_deposit(pub(super) fn deposit_event)]
+	pub enum Event<T: Config> {
+		TestEvent,
+	}
+
+	#[pallet::call]
+	impl<T: Config> Pallet<T> {
+		#[pallet::call_index(0)]
+		#[pallet::weight({0})]
+		pub fn emit_event(_origin: OriginFor<T>) -> DispatchResult {
+			Self::deposit_event(Event::TestEvent);
+			Ok(())
+		}
+
+		#[pallet::call_index(1)]
+		#[pallet::weight({0})]
+		pub fn noop(_origin: OriginFor<T>) -> DispatchResult {
+			Ok(())
+		}
+	}
+}

bizinikiwi/pezframe/benchmarking/pov/src/tests.rs

@@ -0,0 +1,208 @@
+// 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.
+
+//! Test the produces weight functions.
+
+#![cfg(test)]
+
+use super::weights::WeightInfo;
+use mock::Test as T;
+type W = crate::weights::BizinikiwiWeight<T>;
+
+#[test]
+fn writing_is_free() {
+	let w = W::storage_single_value_write().proof_size();
+	assert_eq!(w, 0, "Writing is free");
+}
+
+#[test]
+fn killing_is_free() {
+	// NOTE: This only applies to state version 1.
+	let w = W::storage_single_value_kill().proof_size();
+	assert_eq!(w, 0, "Killing is free");
+}
+
+#[test]
+fn reading_twice_is_the_same_as_once() {
+	let w = W::storage_single_value_read().proof_size();
+	let w2 = W::storage_single_value_read_twice().proof_size();
+	assert_eq!(w, w2, "Reading twice is the same as once");
+}
+
+#[test]
+fn storage_single_value_ignored_read_no_pov() {
+	let w = W::storage_single_value_ignored_read();
+	assert_eq!(w.proof_size(), 0, "Ignored PoV does not result in PoV");
+}
+
+#[test]
+fn storage_single_value_ignored_some_read_has_pov() {
+	let w = W::storage_single_value_ignored_some_read();
+	assert!(w.proof_size() != 0, "Ignored some does result in PoV");
+}
+
+/// Reading the same value from a map does not increase the PoV.
+#[test]
+fn storage_1m_map_one_entry_repeated_read_const() {
+	let weight = W::storage_1m_map_one_entry_repeated_read;
+	let w0 = weight(0).proof_size();
+	assert!(w0 > 0, "There is a base weight");
+
+	let w1 = weight(1).proof_size();
+	assert_eq!(w0, w1, "Component does not matter");
+}
+
+/// Reading multiple values multiple times from a map increases the PoV by the number of reads.
+#[test]
+fn storage_1m_map_multiple_entry_repeated_read_single_linear() {
+	let weight = W::storage_1m_map_multiple_entry_repeated_read;
+	let w0 = weight(0).proof_size();
+
+	let w1 = weight(1).proof_size() - w0;
+	assert!(w1 > 0, "Component matters");
+
+	let wm = weight(1000).proof_size();
+	assert_eq!(w1 * 1000 + w0, wm, "x scales linearly");
+}
+
+/// Check that reading two maps at once increases the PoV linearly per map.
+#[test]
+fn storage_map_read_per_component_double_linear() {
+	let weight = W::storage_map_read_per_component;
+	let w00 = weight(0, 0).proof_size();
+
+	let w10 = weight(1, 0).proof_size() - w00;
+	let w01 = weight(0, 1).proof_size() - w00;
+	assert!(w10 > 0 && w01 > 0, "Components matter");
+	assert!(w10 != w01, "Each map has its own component");
+
+	let wm0 = weight(1000, 0).proof_size();
+	let w0m = weight(0, 1000).proof_size();
+	assert_eq!(w00 + w10 * 1000, wm0, "x scales linearly");
+	assert_eq!(w00 + w01 * 1000, w0m, "y scales linearly");
+
+	let wmm = weight(1000, 1000).proof_size();
+	assert_eq!(wmm + w00, wm0 + w0m, "x + y scales linearly");
+}
+
+/// The proof size estimation takes the measured sizes into account and therefore increases with the
+/// number of layers.
+#[test]
+fn additional_layers_do_not_matter() {
+	let w2 = W::storage_1m_map_read_one_value_two_additional_layers().proof_size();
+	let w3 = W::storage_1m_map_read_one_value_three_additional_layers().proof_size();
+	let w4 = W::storage_1m_map_read_one_value_four_additional_layers().proof_size();
+	assert!(w3 > w2 && w4 > w3, "Additional layers do matter");
+}
+
+/// Check that the measured value size instead of the MEL is used.
+#[test]
+fn linear_measured_size_works() {
+	let weight = W::measured_storage_value_read_linear_size;
+
+	let w0 = weight(0).proof_size();
+	let w1 = weight(1).proof_size() - w0;
+
+	assert_eq!(w1, 1, "x scales with a factor of 1");
+	let wm = weight(1000).proof_size();
+	assert_eq!(w1 * 1000 + w0, wm, "x scales linearly");
+}
+
+// vice-versa of above `linear_measured_size_works`.
+#[test]
+fn linear_mel_size_works() {
+	let weight = W::mel_storage_value_read_linear_size;
+
+	let w1 = weight(1).proof_size();
+	let wm = weight(1000).proof_size();
+	assert_eq!(w1, wm, "PoV size is const");
+}
+
+/// Although there is no estimation possible, it uses the recorded proof size as best effort.
+#[test]
+fn unbounded_read_best_effort() {
+	let w = W::storage_value_unbounded_read().proof_size();
+	assert!(w > 0, "There is a weight");
+}
+
+/// For mixed unbounded and bounded reads, the bounded part still increases the PoV.
+#[test]
+fn partial_unbounded_read_best_effort() {
+	let w_unbounded = W::storage_value_unbounded_read().proof_size();
+	let w_bounded = W::storage_value_bounded_read().proof_size();
+	let w_both = W::storage_value_bounded_and_unbounded_read().proof_size();
+
+	assert!(w_both > w_bounded && w_both > w_unbounded, "The bounded part increases the PoV");
+}
+
+#[test]
+fn emit_event_is_free() {
+	let w = W::emit_event().proof_size();
+	assert_eq!(w, 0, "Emitting an event is free");
+}
+
+#[test]
+fn noop_is_free() {
+	let w = W::noop().proof_size();
+	assert_eq!(w, 0, "Noop is free");
+}
+
+mod mock {
+	use pezframe_support::derive_impl;
+	use pezsp_runtime::testing::H256;
+
+	type Block = pezframe_system::mocking::MockBlock<Test>;
+
+	pezframe_support::construct_runtime!(
+		pub enum Test
+		{
+			System: pezframe_system,
+			Baseline: crate,
+		}
+	);
+
+	#[derive_impl(pezframe_system::config_preludes::TestDefaultConfig)]
+	impl pezframe_system::Config for Test {
+		type BaseCallFilter = pezframe_support::traits::Everything;
+		type BlockWeights = ();
+		type BlockLength = ();
+		type DbWeight = ();
+		type RuntimeOrigin = RuntimeOrigin;
+		type Nonce = u32;
+		type RuntimeCall = RuntimeCall;
+		type Hash = H256;
+		type Hashing = ::pezsp_runtime::traits::BlakeTwo256;
+		type AccountId = u32;
+		type Lookup = pezsp_runtime::traits::IdentityLookup<Self::AccountId>;
+		type Block = Block;
+		type RuntimeEvent = RuntimeEvent;
+		type BlockHashCount = ();
+		type Version = ();
+		type PalletInfo = PalletInfo;
+		type AccountData = ();
+		type OnNewAccount = ();
+		type OnKilledAccount = ();
+		type SystemWeightInfo = ();
+		type SS58Prefix = ();
+		type OnSetCode = ();
+		type MaxConsumers = pezframe_support::traits::ConstU32<16>;
+	}
+
+	impl crate::Config for Test {
+		type RuntimeEvent = RuntimeEvent;
+	}
+}

bizinikiwi/pezframe/benchmarking/pov/src/weights.rs

@@ -0,0 +1,895 @@
+// 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.
+
+// 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.
+
+//! Autogenerated weights for `pezframe_benchmarking_pallet_pov`
+//!
+//! THIS FILE WAS AUTO-GENERATED USING THE BIZINIKIWI BENCHMARK CLI VERSION 32.0.0
+//! DATE: 2025-02-21, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]`
+//! WORST CASE MAP SIZE: `1000000`
+//! HOSTNAME: `4563561839a5`, CPU: `Intel(R) Xeon(R) CPU @ 2.60GHz`
+//! WASM-EXECUTION: `Compiled`, CHAIN: `None`, DB CACHE: `1024`
+
+// Executed Command:
+// frame-omni-bencher
+// v1
+// benchmark
+// pallet
+// --extrinsic=*
+// --runtime=target/production/wbuild/kitchensink-runtime/kitchensink_runtime.wasm
+// --pallet=pezframe_benchmarking_pallet_pov
+// --header=/__w/pezkuwi-sdk/pezkuwi-sdk/bizinikiwi/HEADER-APACHE2
+// --output=/__w/pezkuwi-sdk/pezkuwi-sdk/bizinikiwi/pezframe/benchmarking/pov/src/weights.rs
+// --wasm-execution=compiled
+// --steps=50
+// --repeat=20
+// --heap-pages=4096
+// --template=bizinikiwi/.maintain/frame-weight-template.hbs
+// --no-storage-info
+// --no-min-squares
+// --no-median-slopes
+// --genesis-builder-policy=none
+// --exclude-pallets=pezpallet_xcm,pezpallet_xcm_benchmarks::fungible,pezpallet_xcm_benchmarks::generic,pezpallet_nomination_pools,pezpallet_remark,pezpallet_transaction_storage,pezpallet_election_provider_multi_block,pezpallet_election_provider_multi_block::signed,pezpallet_election_provider_multi_block::unsigned,pezpallet_election_provider_multi_block::verifier
+
+#![cfg_attr(rustfmt, rustfmt_skip)]
+#![allow(unused_parens)]
+#![allow(unused_imports)]
+#![allow(missing_docs)]
+#![allow(dead_code)]
+
+use pezframe_support::{traits::Get, weights::{Weight, constants::RocksDbWeight}};
+use core::marker::PhantomData;
+
+/// Weight functions needed for `pezframe_benchmarking_pallet_pov`.
+pub trait WeightInfo {
+	fn storage_single_value_read() -> Weight;
+	fn storage_single_value_ignored_read() -> Weight;
+	fn storage_single_value_ignored_some_read() -> Weight;
+	fn storage_single_value_read_twice() -> Weight;
+	fn storage_single_value_write() -> Weight;
+	fn storage_single_value_kill() -> Weight;
+	fn storage_1m_map_read_one_value_two_additional_layers() -> Weight;
+	fn storage_1m_map_read_one_value_three_additional_layers() -> Weight;
+	fn storage_1m_map_read_one_value_four_additional_layers() -> Weight;
+	fn storage_map_read_per_component(n: u32, m: u32, ) -> Weight;
+	fn storage_map_read_per_component_one_ignored(n: u32, m: u32, ) -> Weight;
+	fn storage_1m_map_one_entry_repeated_read(n: u32, ) -> Weight;
+	fn storage_1m_map_multiple_entry_repeated_read(n: u32, ) -> Weight;
+	fn storage_1m_double_map_read_per_component(n: u32, ) -> Weight;
+	fn storage_value_bounded_read() -> Weight;
+	fn storage_value_unbounded_read() -> Weight;
+	fn storage_value_unbounded_ignored_read() -> Weight;
+	fn storage_value_bounded_and_unbounded_read() -> Weight;
+	fn measured_storage_value_read_linear_size(l: u32, ) -> Weight;
+	fn mel_storage_value_read_linear_size(l: u32, ) -> Weight;
+	fn measured_storage_double_value_read_linear_size(l: u32, ) -> Weight;
+	fn mel_storage_double_value_read_linear_size(l: u32, ) -> Weight;
+	fn mel_mixed_storage_double_value_read_linear_size(l: u32, ) -> Weight;
+	fn measured_mixed_storage_double_value_read_linear_size(l: u32, ) -> Weight;
+	fn storage_map_unbounded_both_measured_read(i: u32, ) -> Weight;
+	fn storage_map_partial_unbounded_read(i: u32, ) -> Weight;
+	fn storage_map_partial_unbounded_ignored_read(i: u32, ) -> Weight;
+	fn emit_event() -> Weight;
+	fn noop() -> Weight;
+	fn storage_iteration() -> Weight;
+	fn storage_root_is_the_same_every_time(i: u32, ) -> Weight;
+}
+
+/// Weights for `pezframe_benchmarking_pallet_pov` using the Bizinikiwi node and recommended hardware.
+pub struct BizinikiwiWeight<T>(PhantomData<T>);
+impl<T: pezframe_system::Config> WeightInfo for BizinikiwiWeight<T> {
+	/// Storage: `Pov::Value` (r:1 w:0)
+	/// Proof: `Pov::Value` (`max_values`: Some(1), `max_size`: Some(4), added: 499, mode: `MaxEncodedLen`)
+	fn storage_single_value_read() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `8`
+		//  Estimated: `1489`
+		// Minimum execution time: 1_817_000 picoseconds.
+		Weight::from_parts(1_881_000, 1489)
+			.saturating_add(T::DbWeight::get().reads(1_u64))
+	}
+	/// Storage: `Pov::Value` (r:1 w:0)
+	/// Proof: `Pov::Value` (`max_values`: Some(1), `max_size`: Some(4), added: 499, mode: `Ignored`)
+	fn storage_single_value_ignored_read() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `8`
+		//  Estimated: `0`
+		// Minimum execution time: 1_782_000 picoseconds.
+		Weight::from_parts(1_910_000, 0)
+			.saturating_add(T::DbWeight::get().reads(1_u64))
+	}
+	/// Storage: `Pov::Value` (r:1 w:0)
+	/// Proof: `Pov::Value` (`max_values`: Some(1), `max_size`: Some(4), added: 499, mode: `MaxEncodedLen`)
+	/// Storage: `Pov::Value2` (r:1 w:0)
+	/// Proof: `Pov::Value2` (`max_values`: Some(1), `max_size`: Some(4), added: 499, mode: `Ignored`)
+	fn storage_single_value_ignored_some_read() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `35`
+		//  Estimated: `1489`
+		// Minimum execution time: 3_713_000 picoseconds.
+		Weight::from_parts(3_806_000, 1489)
+			.saturating_add(T::DbWeight::get().reads(2_u64))
+	}
+	/// Storage: `Pov::Value` (r:1 w:0)
+	/// Proof: `Pov::Value` (`max_values`: Some(1), `max_size`: Some(4), added: 499, mode: `MaxEncodedLen`)
+	fn storage_single_value_read_twice() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `8`
+		//  Estimated: `1489`
+		// Minimum execution time: 2_252_000 picoseconds.
+		Weight::from_parts(2_394_000, 1489)
+			.saturating_add(T::DbWeight::get().reads(1_u64))
+	}
+	/// Storage: `Pov::Value` (r:0 w:1)
+	/// Proof: `Pov::Value` (`max_values`: Some(1), `max_size`: Some(4), added: 499, mode: `MaxEncodedLen`)
+	fn storage_single_value_write() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0`
+		//  Estimated: `0`
+		// Minimum execution time: 376_000 picoseconds.
+		Weight::from_parts(448_000, 0)
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+	}
+	/// Storage: `Pov::Value` (r:0 w:1)
+	/// Proof: `Pov::Value` (`max_values`: Some(1), `max_size`: Some(4), added: 499, mode: `MaxEncodedLen`)
+	fn storage_single_value_kill() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0`
+		//  Estimated: `0`
+		// Minimum execution time: 311_000 picoseconds.
+		Weight::from_parts(371_000, 0)
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+	}
+	/// Storage: `Pov::Map1M` (r:1 w:0)
+	/// Proof: `Pov::Map1M` (`max_values`: Some(1000000), `max_size`: Some(36), added: 2511, mode: `Measured`)
+	fn storage_1m_map_read_one_value_two_additional_layers() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `1182`
+		//  Estimated: `4647`
+		// Minimum execution time: 11_814_000 picoseconds.
+		Weight::from_parts(12_286_000, 4647)
+			.saturating_add(T::DbWeight::get().reads(1_u64))
+	}
+	/// Storage: `Pov::Map1M` (r:1 w:0)
+	/// Proof: `Pov::Map1M` (`max_values`: Some(1000000), `max_size`: Some(36), added: 2511, mode: `Measured`)
+	fn storage_1m_map_read_one_value_three_additional_layers() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `1485`
+		//  Estimated: `4950`
+		// Minimum execution time: 15_590_000 picoseconds.
+		Weight::from_parts(16_034_000, 4950)
+			.saturating_add(T::DbWeight::get().reads(1_u64))
+	}
+	/// Storage: `Pov::Map1M` (r:1 w:0)
+	/// Proof: `Pov::Map1M` (`max_values`: Some(1000000), `max_size`: Some(36), added: 2511, mode: `Measured`)
+	fn storage_1m_map_read_one_value_four_additional_layers() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `2018`
+		//  Estimated: `5483`
+		// Minimum execution time: 14_940_000 picoseconds.
+		Weight::from_parts(15_410_000, 5483)
+			.saturating_add(T::DbWeight::get().reads(1_u64))
+	}
+	/// Storage: `Pov::Map1M` (r:100 w:0)
+	/// Proof: `Pov::Map1M` (`max_values`: Some(1000000), `max_size`: Some(36), added: 2511, mode: `MaxEncodedLen`)
+	/// Storage: `Pov::Map16M` (r:100 w:0)
+	/// Proof: `Pov::Map16M` (`max_values`: Some(16000000), `max_size`: Some(36), added: 3006, mode: `MaxEncodedLen`)
+	/// The range of component `n` is `[0, 100]`.
+	/// The range of component `m` is `[0, 100]`.
+	fn storage_map_read_per_component(n: u32, m: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `390 + m * (188 ±0) + n * (188 ±0)`
+		//  Estimated: `990 + m * (2511 ±0) + n * (3006 ±0)`
+		// Minimum execution time: 476_299_000 picoseconds.
+		Weight::from_parts(291_597_275, 990)
+			// Standard Error: 33_182
+			.saturating_add(Weight::from_parts(2_645_788, 0).saturating_mul(n.into()))
+			// Standard Error: 33_182
+			.saturating_add(Weight::from_parts(2_663_663, 0).saturating_mul(m.into()))
+			.saturating_add(T::DbWeight::get().reads((1_u64).saturating_mul(n.into())))
+			.saturating_add(T::DbWeight::get().reads((1_u64).saturating_mul(m.into())))
+			.saturating_add(Weight::from_parts(0, 2511).saturating_mul(m.into()))
+			.saturating_add(Weight::from_parts(0, 3006).saturating_mul(n.into()))
+	}
+	/// Storage: `Pov::Map1M` (r:100 w:0)
+	/// Proof: `Pov::Map1M` (`max_values`: Some(1000000), `max_size`: Some(36), added: 2511, mode: `Ignored`)
+	/// Storage: `Pov::Map16M` (r:100 w:0)
+	/// Proof: `Pov::Map16M` (`max_values`: Some(16000000), `max_size`: Some(36), added: 3006, mode: `MaxEncodedLen`)
+	/// The range of component `n` is `[0, 100]`.
+	/// The range of component `m` is `[0, 100]`.
+	fn storage_map_read_per_component_one_ignored(n: u32, m: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `390 + m * (188 ±0) + n * (188 ±0)`
+		//  Estimated: `1560 + m * (189 ±0) + n * (3006 ±0)`
+		// Minimum execution time: 478_548_000 picoseconds.
+		Weight::from_parts(286_747_135, 1560)
+			// Standard Error: 32_978
+			.saturating_add(Weight::from_parts(2_691_677, 0).saturating_mul(n.into()))
+			// Standard Error: 32_978
+			.saturating_add(Weight::from_parts(2_700_753, 0).saturating_mul(m.into()))
+			.saturating_add(T::DbWeight::get().reads((1_u64).saturating_mul(n.into())))
+			.saturating_add(T::DbWeight::get().reads((1_u64).saturating_mul(m.into())))
+			.saturating_add(Weight::from_parts(0, 189).saturating_mul(m.into()))
+			.saturating_add(Weight::from_parts(0, 3006).saturating_mul(n.into()))
+	}
+	/// Storage: `Pov::Map1M` (r:1 w:0)
+	/// Proof: `Pov::Map1M` (`max_values`: Some(1000000), `max_size`: Some(36), added: 2511, mode: `MaxEncodedLen`)
+	/// The range of component `n` is `[0, 100]`.
+	fn storage_1m_map_one_entry_repeated_read(n: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `41`
+		//  Estimated: `3501`
+		// Minimum execution time: 166_000 picoseconds.
+		Weight::from_parts(1_973_792, 3501)
+			// Standard Error: 952
+			.saturating_add(Weight::from_parts(1_147_407, 0).saturating_mul(n.into()))
+			.saturating_add(T::DbWeight::get().reads(1_u64))
+	}
+	/// Storage: `Pov::Map1M` (r:100 w:0)
+	/// Proof: `Pov::Map1M` (`max_values`: Some(1000000), `max_size`: Some(36), added: 2511, mode: `MaxEncodedLen`)
+	/// The range of component `n` is `[0, 100]`.
+	fn storage_1m_map_multiple_entry_repeated_read(n: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `18 + n * (40 ±0)`
+		//  Estimated: `990 + n * (2511 ±0)`
+		// Minimum execution time: 161_000 picoseconds.
+		Weight::from_parts(187_000, 990)
+			// Standard Error: 3_863
+			.saturating_add(Weight::from_parts(13_643_264, 0).saturating_mul(n.into()))
+			.saturating_add(T::DbWeight::get().reads((1_u64).saturating_mul(n.into())))
+			.saturating_add(Weight::from_parts(0, 2511).saturating_mul(n.into()))
+	}
+	/// Storage: `Pov::DoubleMap1M` (r:1024 w:0)
+	/// Proof: `Pov::DoubleMap1M` (`max_values`: Some(1000000), `max_size`: Some(68), added: 2543, mode: `MaxEncodedLen`)
+	/// The range of component `n` is `[0, 1024]`.
+	fn storage_1m_double_map_read_per_component(n: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `21809 + n * (57 ±0)`
+		//  Estimated: `990 + n * (2543 ±0)`
+		// Minimum execution time: 320_000 picoseconds.
+		Weight::from_parts(88_877_073, 990)
+			// Standard Error: 3_857
+			.saturating_add(Weight::from_parts(4_894_961, 0).saturating_mul(n.into()))
+			.saturating_add(T::DbWeight::get().reads((1_u64).saturating_mul(n.into())))
+			.saturating_add(Weight::from_parts(0, 2543).saturating_mul(n.into()))
+	}
+	/// Storage: `Pov::BoundedValue` (r:1 w:0)
+	/// Proof: `Pov::BoundedValue` (`max_values`: Some(1), `max_size`: Some(33), added: 528, mode: `MaxEncodedLen`)
+	fn storage_value_bounded_read() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0`
+		//  Estimated: `1518`
+		// Minimum execution time: 670_000 picoseconds.
+		Weight::from_parts(720_000, 1518)
+			.saturating_add(T::DbWeight::get().reads(1_u64))
+	}
+	/// Storage: `Pov::UnboundedValue` (r:1 w:0)
+	/// Proof: `Pov::UnboundedValue` (`max_values`: Some(1), `max_size`: None, mode: `Measured`)
+	fn storage_value_unbounded_read() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0`
+		//  Estimated: `1485`
+		// Minimum execution time: 655_000 picoseconds.
+		Weight::from_parts(698_000, 1485)
+			.saturating_add(T::DbWeight::get().reads(1_u64))
+	}
+	/// Storage: `Pov::UnboundedValue` (r:1 w:0)
+	/// Proof: `Pov::UnboundedValue` (`max_values`: Some(1), `max_size`: None, mode: `Ignored`)
+	fn storage_value_unbounded_ignored_read() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0`
+		//  Estimated: `0`
+		// Minimum execution time: 680_000 picoseconds.
+		Weight::from_parts(713_000, 0)
+			.saturating_add(T::DbWeight::get().reads(1_u64))
+	}
+	/// Storage: `Pov::UnboundedValue` (r:1 w:0)
+	/// Proof: `Pov::UnboundedValue` (`max_values`: Some(1), `max_size`: None, mode: `Measured`)
+	/// Storage: `Pov::BoundedValue` (r:1 w:0)
+	/// Proof: `Pov::BoundedValue` (`max_values`: Some(1), `max_size`: Some(33), added: 528, mode: `MaxEncodedLen`)
+	fn storage_value_bounded_and_unbounded_read() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `534`
+		//  Estimated: `2019`
+		// Minimum execution time: 4_310_000 picoseconds.
+		Weight::from_parts(4_559_000, 2019)
+			.saturating_add(T::DbWeight::get().reads(2_u64))
+	}
+	/// Storage: `Pov::LargeValue` (r:1 w:0)
+	/// Proof: `Pov::LargeValue` (`max_values`: Some(1), `max_size`: Some(4194308), added: 4194803, mode: `Measured`)
+	/// The range of component `l` is `[0, 4194304]`.
+	fn measured_storage_value_read_linear_size(l: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `13 + l * (1 ±0)`
+		//  Estimated: `1497 + l * (1 ±0)`
+		// Minimum execution time: 1_872_000 picoseconds.
+		Weight::from_parts(1_929_000, 1497)
+			// Standard Error: 132
+			.saturating_add(Weight::from_parts(11_970, 0).saturating_mul(l.into()))
+			.saturating_add(T::DbWeight::get().reads(1_u64))
+			.saturating_add(Weight::from_parts(0, 1).saturating_mul(l.into()))
+	}
+	/// Storage: `Pov::LargeValue` (r:1 w:0)
+	/// Proof: `Pov::LargeValue` (`max_values`: Some(1), `max_size`: Some(4194308), added: 4194803, mode: `MaxEncodedLen`)
+	/// The range of component `l` is `[0, 4194304]`.
+	fn mel_storage_value_read_linear_size(l: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `13 + l * (1 ±0)`
+		//  Estimated: `4195793`
+		// Minimum execution time: 1_826_000 picoseconds.
+		Weight::from_parts(1_899_000, 4195793)
+			// Standard Error: 135
+			.saturating_add(Weight::from_parts(12_037, 0).saturating_mul(l.into()))
+			.saturating_add(T::DbWeight::get().reads(1_u64))
+	}
+	/// Storage: `Pov::LargeValue` (r:1 w:0)
+	/// Proof: `Pov::LargeValue` (`max_values`: Some(1), `max_size`: Some(4194308), added: 4194803, mode: `Measured`)
+	/// Storage: `Pov::LargeValue2` (r:1 w:0)
+	/// Proof: `Pov::LargeValue2` (`max_values`: Some(1), `max_size`: Some(4194308), added: 4194803, mode: `Measured`)
+	/// The range of component `l` is `[0, 4194304]`.
+	fn measured_storage_double_value_read_linear_size(l: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `46 + l * (2 ±0)`
+		//  Estimated: `1530 + l * (2 ±0)`
+		// Minimum execution time: 3_663_000 picoseconds.
+		Weight::from_parts(3_837_000, 1530)
+			// Standard Error: 265
+			.saturating_add(Weight::from_parts(23_779, 0).saturating_mul(l.into()))
+			.saturating_add(T::DbWeight::get().reads(2_u64))
+			.saturating_add(Weight::from_parts(0, 2).saturating_mul(l.into()))
+	}
+	/// Storage: `Pov::LargeValue` (r:1 w:0)
+	/// Proof: `Pov::LargeValue` (`max_values`: Some(1), `max_size`: Some(4194308), added: 4194803, mode: `MaxEncodedLen`)
+	/// Storage: `Pov::LargeValue2` (r:1 w:0)
+	/// Proof: `Pov::LargeValue2` (`max_values`: Some(1), `max_size`: Some(4194308), added: 4194803, mode: `MaxEncodedLen`)
+	/// The range of component `l` is `[0, 4194304]`.
+	fn mel_storage_double_value_read_linear_size(l: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `46 + l * (2 ±0)`
+		//  Estimated: `4195793`
+		// Minimum execution time: 3_717_000 picoseconds.
+		Weight::from_parts(3_763_000, 4195793)
+			// Standard Error: 265
+			.saturating_add(Weight::from_parts(23_782, 0).saturating_mul(l.into()))
+			.saturating_add(T::DbWeight::get().reads(2_u64))
+	}
+	/// Storage: `Pov::LargeValue` (r:1 w:0)
+	/// Proof: `Pov::LargeValue` (`max_values`: Some(1), `max_size`: Some(4194308), added: 4194803, mode: `MaxEncodedLen`)
+	/// Storage: `Pov::LargeValue2` (r:1 w:0)
+	/// Proof: `Pov::LargeValue2` (`max_values`: Some(1), `max_size`: Some(4194308), added: 4194803, mode: `Measured`)
+	/// The range of component `l` is `[0, 4194304]`.
+	fn mel_mixed_storage_double_value_read_linear_size(l: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `46 + l * (2 ±0)`
+		//  Estimated: `4195793 + l * (2 ±0)`
+		// Minimum execution time: 3_720_000 picoseconds.
+		Weight::from_parts(3_809_000, 4195793)
+			// Standard Error: 266
+			.saturating_add(Weight::from_parts(23_788, 0).saturating_mul(l.into()))
+			.saturating_add(T::DbWeight::get().reads(2_u64))
+			.saturating_add(Weight::from_parts(0, 2).saturating_mul(l.into()))
+	}
+	/// Storage: `Pov::LargeValue` (r:1 w:0)
+	/// Proof: `Pov::LargeValue` (`max_values`: Some(1), `max_size`: Some(4194308), added: 4194803, mode: `Measured`)
+	/// Storage: `Pov::LargeValue2` (r:1 w:0)
+	/// Proof: `Pov::LargeValue2` (`max_values`: Some(1), `max_size`: Some(4194308), added: 4194803, mode: `MaxEncodedLen`)
+	/// The range of component `l` is `[0, 4194304]`.
+	fn measured_mixed_storage_double_value_read_linear_size(l: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `46 + l * (2 ±0)`
+		//  Estimated: `4195793 + l * (2 ±0)`
+		// Minimum execution time: 3_660_000 picoseconds.
+		Weight::from_parts(3_792_000, 4195793)
+			// Standard Error: 266
+			.saturating_add(Weight::from_parts(23_795, 0).saturating_mul(l.into()))
+			.saturating_add(T::DbWeight::get().reads(2_u64))
+			.saturating_add(Weight::from_parts(0, 2).saturating_mul(l.into()))
+	}
+	/// Storage: `Pov::UnboundedMap` (r:1 w:0)
+	/// Proof: `Pov::UnboundedMap` (`max_values`: None, `max_size`: None, mode: `Measured`)
+	/// Storage: `Pov::UnboundedMap2` (r:1 w:0)
+	/// Proof: `Pov::UnboundedMap2` (`max_values`: None, `max_size`: None, mode: `Measured`)
+	/// The range of component `i` is `[0, 1000]`.
+	fn storage_map_unbounded_both_measured_read(i: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `104 + i * (8 ±0)`
+		//  Estimated: `3568 + i * (8 ±0)`
+		// Minimum execution time: 7_143_000 picoseconds.
+		Weight::from_parts(7_945_447, 3568)
+			// Standard Error: 27
+			.saturating_add(Weight::from_parts(2_983, 0).saturating_mul(i.into()))
+			.saturating_add(T::DbWeight::get().reads(2_u64))
+			.saturating_add(Weight::from_parts(0, 8).saturating_mul(i.into()))
+	}
+	/// Storage: `Pov::Map1M` (r:1 w:0)
+	/// Proof: `Pov::Map1M` (`max_values`: Some(1000000), `max_size`: Some(36), added: 2511, mode: `MaxEncodedLen`)
+	/// Storage: `Pov::UnboundedMap` (r:1 w:0)
+	/// Proof: `Pov::UnboundedMap` (`max_values`: None, `max_size`: None, mode: `Measured`)
+	/// The range of component `i` is `[0, 1000]`.
+	fn storage_map_partial_unbounded_read(i: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `103 + i * (4 ±0)`
+		//  Estimated: `3567 + i * (4 ±0)`
+		// Minimum execution time: 7_254_000 picoseconds.
+		Weight::from_parts(7_919_811, 3567)
+			// Standard Error: 22
+			.saturating_add(Weight::from_parts(1_670, 0).saturating_mul(i.into()))
+			.saturating_add(T::DbWeight::get().reads(2_u64))
+			.saturating_add(Weight::from_parts(0, 4).saturating_mul(i.into()))
+	}
+	/// Storage: `Pov::Map1M` (r:1 w:0)
+	/// Proof: `Pov::Map1M` (`max_values`: Some(1000000), `max_size`: Some(36), added: 2511, mode: `MaxEncodedLen`)
+	/// Storage: `Pov::UnboundedMap` (r:1 w:0)
+	/// Proof: `Pov::UnboundedMap` (`max_values`: None, `max_size`: None, mode: `Ignored`)
+	/// The range of component `i` is `[0, 1000]`.
+	fn storage_map_partial_unbounded_ignored_read(i: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `103 + i * (4 ±0)`
+		//  Estimated: `3501 + i * (4 ±0)`
+		// Minimum execution time: 7_195_000 picoseconds.
+		Weight::from_parts(7_998_073, 3501)
+			// Standard Error: 23
+			.saturating_add(Weight::from_parts(1_576, 0).saturating_mul(i.into()))
+			.saturating_add(T::DbWeight::get().reads(2_u64))
+			.saturating_add(Weight::from_parts(0, 4).saturating_mul(i.into()))
+	}
+	fn emit_event() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0`
+		//  Estimated: `0`
+		// Minimum execution time: 3_961_000 picoseconds.
+		Weight::from_parts(4_092_000, 0)
+	}
+	fn noop() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0`
+		//  Estimated: `0`
+		// Minimum execution time: 1_607_000 picoseconds.
+		Weight::from_parts(1_673_000, 0)
+	}
+	/// Storage: `Pov::UnboundedMapTwox` (r:65001 w:0)
+	/// Proof: `Pov::UnboundedMapTwox` (`max_values`: None, `max_size`: None, mode: `Measured`)
+	fn storage_iteration() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `17985119`
+		//  Estimated: `178863584`
+		// Minimum execution time: 305_702_942_000 picoseconds.
+		Weight::from_parts(311_508_079_000, 178863584)
+			.saturating_add(T::DbWeight::get().reads(65001_u64))
+	}
+	/// Storage: UNKNOWN KEY `0x6b657932` (r:0 w:1)
+	/// Proof: UNKNOWN KEY `0x6b657932` (r:0 w:1)
+	/// The range of component `i` is `[0, 10]`.
+	fn storage_root_is_the_same_every_time(_i: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0`
+		//  Estimated: `0`
+		// Minimum execution time: 359_000 picoseconds.
+		Weight::from_parts(422_427, 0)
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+	}
+}
+
+// For backwards compatibility and tests.
+impl WeightInfo for () {
+	/// Storage: `Pov::Value` (r:1 w:0)
+	/// Proof: `Pov::Value` (`max_values`: Some(1), `max_size`: Some(4), added: 499, mode: `MaxEncodedLen`)
+	fn storage_single_value_read() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `8`
+		//  Estimated: `1489`
+		// Minimum execution time: 1_817_000 picoseconds.
+		Weight::from_parts(1_881_000, 1489)
+			.saturating_add(RocksDbWeight::get().reads(1_u64))
+	}
+	/// Storage: `Pov::Value` (r:1 w:0)
+	/// Proof: `Pov::Value` (`max_values`: Some(1), `max_size`: Some(4), added: 499, mode: `Ignored`)
+	fn storage_single_value_ignored_read() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `8`
+		//  Estimated: `0`
+		// Minimum execution time: 1_782_000 picoseconds.
+		Weight::from_parts(1_910_000, 0)
+			.saturating_add(RocksDbWeight::get().reads(1_u64))
+	}
+	/// Storage: `Pov::Value` (r:1 w:0)
+	/// Proof: `Pov::Value` (`max_values`: Some(1), `max_size`: Some(4), added: 499, mode: `MaxEncodedLen`)
+	/// Storage: `Pov::Value2` (r:1 w:0)
+	/// Proof: `Pov::Value2` (`max_values`: Some(1), `max_size`: Some(4), added: 499, mode: `Ignored`)
+	fn storage_single_value_ignored_some_read() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `35`
+		//  Estimated: `1489`
+		// Minimum execution time: 3_713_000 picoseconds.
+		Weight::from_parts(3_806_000, 1489)
+			.saturating_add(RocksDbWeight::get().reads(2_u64))
+	}
+	/// Storage: `Pov::Value` (r:1 w:0)
+	/// Proof: `Pov::Value` (`max_values`: Some(1), `max_size`: Some(4), added: 499, mode: `MaxEncodedLen`)
+	fn storage_single_value_read_twice() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `8`
+		//  Estimated: `1489`
+		// Minimum execution time: 2_252_000 picoseconds.
+		Weight::from_parts(2_394_000, 1489)
+			.saturating_add(RocksDbWeight::get().reads(1_u64))
+	}
+	/// Storage: `Pov::Value` (r:0 w:1)
+	/// Proof: `Pov::Value` (`max_values`: Some(1), `max_size`: Some(4), added: 499, mode: `MaxEncodedLen`)
+	fn storage_single_value_write() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0`
+		//  Estimated: `0`
+		// Minimum execution time: 376_000 picoseconds.
+		Weight::from_parts(448_000, 0)
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+	}
+	/// Storage: `Pov::Value` (r:0 w:1)
+	/// Proof: `Pov::Value` (`max_values`: Some(1), `max_size`: Some(4), added: 499, mode: `MaxEncodedLen`)
+	fn storage_single_value_kill() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0`
+		//  Estimated: `0`
+		// Minimum execution time: 311_000 picoseconds.
+		Weight::from_parts(371_000, 0)
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+	}
+	/// Storage: `Pov::Map1M` (r:1 w:0)
+	/// Proof: `Pov::Map1M` (`max_values`: Some(1000000), `max_size`: Some(36), added: 2511, mode: `Measured`)
+	fn storage_1m_map_read_one_value_two_additional_layers() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `1182`
+		//  Estimated: `4647`
+		// Minimum execution time: 11_814_000 picoseconds.
+		Weight::from_parts(12_286_000, 4647)
+			.saturating_add(RocksDbWeight::get().reads(1_u64))
+	}
+	/// Storage: `Pov::Map1M` (r:1 w:0)
+	/// Proof: `Pov::Map1M` (`max_values`: Some(1000000), `max_size`: Some(36), added: 2511, mode: `Measured`)
+	fn storage_1m_map_read_one_value_three_additional_layers() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `1485`
+		//  Estimated: `4950`
+		// Minimum execution time: 15_590_000 picoseconds.
+		Weight::from_parts(16_034_000, 4950)
+			.saturating_add(RocksDbWeight::get().reads(1_u64))
+	}
+	/// Storage: `Pov::Map1M` (r:1 w:0)
+	/// Proof: `Pov::Map1M` (`max_values`: Some(1000000), `max_size`: Some(36), added: 2511, mode: `Measured`)
+	fn storage_1m_map_read_one_value_four_additional_layers() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `2018`
+		//  Estimated: `5483`
+		// Minimum execution time: 14_940_000 picoseconds.
+		Weight::from_parts(15_410_000, 5483)
+			.saturating_add(RocksDbWeight::get().reads(1_u64))
+	}
+	/// Storage: `Pov::Map1M` (r:100 w:0)
+	/// Proof: `Pov::Map1M` (`max_values`: Some(1000000), `max_size`: Some(36), added: 2511, mode: `MaxEncodedLen`)
+	/// Storage: `Pov::Map16M` (r:100 w:0)
+	/// Proof: `Pov::Map16M` (`max_values`: Some(16000000), `max_size`: Some(36), added: 3006, mode: `MaxEncodedLen`)
+	/// The range of component `n` is `[0, 100]`.
+	/// The range of component `m` is `[0, 100]`.
+	fn storage_map_read_per_component(n: u32, m: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `390 + m * (188 ±0) + n * (188 ±0)`
+		//  Estimated: `990 + m * (2511 ±0) + n * (3006 ±0)`
+		// Minimum execution time: 476_299_000 picoseconds.
+		Weight::from_parts(291_597_275, 990)
+			// Standard Error: 33_182
+			.saturating_add(Weight::from_parts(2_645_788, 0).saturating_mul(n.into()))
+			// Standard Error: 33_182
+			.saturating_add(Weight::from_parts(2_663_663, 0).saturating_mul(m.into()))
+			.saturating_add(RocksDbWeight::get().reads((1_u64).saturating_mul(n.into())))
+			.saturating_add(RocksDbWeight::get().reads((1_u64).saturating_mul(m.into())))
+			.saturating_add(Weight::from_parts(0, 2511).saturating_mul(m.into()))
+			.saturating_add(Weight::from_parts(0, 3006).saturating_mul(n.into()))
+	}
+	/// Storage: `Pov::Map1M` (r:100 w:0)
+	/// Proof: `Pov::Map1M` (`max_values`: Some(1000000), `max_size`: Some(36), added: 2511, mode: `Ignored`)
+	/// Storage: `Pov::Map16M` (r:100 w:0)
+	/// Proof: `Pov::Map16M` (`max_values`: Some(16000000), `max_size`: Some(36), added: 3006, mode: `MaxEncodedLen`)
+	/// The range of component `n` is `[0, 100]`.
+	/// The range of component `m` is `[0, 100]`.
+	fn storage_map_read_per_component_one_ignored(n: u32, m: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `390 + m * (188 ±0) + n * (188 ±0)`
+		//  Estimated: `1560 + m * (189 ±0) + n * (3006 ±0)`
+		// Minimum execution time: 478_548_000 picoseconds.
+		Weight::from_parts(286_747_135, 1560)
+			// Standard Error: 32_978
+			.saturating_add(Weight::from_parts(2_691_677, 0).saturating_mul(n.into()))
+			// Standard Error: 32_978
+			.saturating_add(Weight::from_parts(2_700_753, 0).saturating_mul(m.into()))
+			.saturating_add(RocksDbWeight::get().reads((1_u64).saturating_mul(n.into())))
+			.saturating_add(RocksDbWeight::get().reads((1_u64).saturating_mul(m.into())))
+			.saturating_add(Weight::from_parts(0, 189).saturating_mul(m.into()))
+			.saturating_add(Weight::from_parts(0, 3006).saturating_mul(n.into()))
+	}
+	/// Storage: `Pov::Map1M` (r:1 w:0)
+	/// Proof: `Pov::Map1M` (`max_values`: Some(1000000), `max_size`: Some(36), added: 2511, mode: `MaxEncodedLen`)
+	/// The range of component `n` is `[0, 100]`.
+	fn storage_1m_map_one_entry_repeated_read(n: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `41`
+		//  Estimated: `3501`
+		// Minimum execution time: 166_000 picoseconds.
+		Weight::from_parts(1_973_792, 3501)
+			// Standard Error: 952
+			.saturating_add(Weight::from_parts(1_147_407, 0).saturating_mul(n.into()))
+			.saturating_add(RocksDbWeight::get().reads(1_u64))
+	}
+	/// Storage: `Pov::Map1M` (r:100 w:0)
+	/// Proof: `Pov::Map1M` (`max_values`: Some(1000000), `max_size`: Some(36), added: 2511, mode: `MaxEncodedLen`)
+	/// The range of component `n` is `[0, 100]`.
+	fn storage_1m_map_multiple_entry_repeated_read(n: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `18 + n * (40 ±0)`
+		//  Estimated: `990 + n * (2511 ±0)`
+		// Minimum execution time: 161_000 picoseconds.
+		Weight::from_parts(187_000, 990)
+			// Standard Error: 3_863
+			.saturating_add(Weight::from_parts(13_643_264, 0).saturating_mul(n.into()))
+			.saturating_add(RocksDbWeight::get().reads((1_u64).saturating_mul(n.into())))
+			.saturating_add(Weight::from_parts(0, 2511).saturating_mul(n.into()))
+	}
+	/// Storage: `Pov::DoubleMap1M` (r:1024 w:0)
+	/// Proof: `Pov::DoubleMap1M` (`max_values`: Some(1000000), `max_size`: Some(68), added: 2543, mode: `MaxEncodedLen`)
+	/// The range of component `n` is `[0, 1024]`.
+	fn storage_1m_double_map_read_per_component(n: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `21809 + n * (57 ±0)`
+		//  Estimated: `990 + n * (2543 ±0)`
+		// Minimum execution time: 320_000 picoseconds.
+		Weight::from_parts(88_877_073, 990)
+			// Standard Error: 3_857
+			.saturating_add(Weight::from_parts(4_894_961, 0).saturating_mul(n.into()))
+			.saturating_add(RocksDbWeight::get().reads((1_u64).saturating_mul(n.into())))
+			.saturating_add(Weight::from_parts(0, 2543).saturating_mul(n.into()))
+	}
+	/// Storage: `Pov::BoundedValue` (r:1 w:0)
+	/// Proof: `Pov::BoundedValue` (`max_values`: Some(1), `max_size`: Some(33), added: 528, mode: `MaxEncodedLen`)
+	fn storage_value_bounded_read() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0`
+		//  Estimated: `1518`
+		// Minimum execution time: 670_000 picoseconds.
+		Weight::from_parts(720_000, 1518)
+			.saturating_add(RocksDbWeight::get().reads(1_u64))
+	}
+	/// Storage: `Pov::UnboundedValue` (r:1 w:0)
+	/// Proof: `Pov::UnboundedValue` (`max_values`: Some(1), `max_size`: None, mode: `Measured`)
+	fn storage_value_unbounded_read() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0`
+		//  Estimated: `1485`
+		// Minimum execution time: 655_000 picoseconds.
+		Weight::from_parts(698_000, 1485)
+			.saturating_add(RocksDbWeight::get().reads(1_u64))
+	}
+	/// Storage: `Pov::UnboundedValue` (r:1 w:0)
+	/// Proof: `Pov::UnboundedValue` (`max_values`: Some(1), `max_size`: None, mode: `Ignored`)
+	fn storage_value_unbounded_ignored_read() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0`
+		//  Estimated: `0`
+		// Minimum execution time: 680_000 picoseconds.
+		Weight::from_parts(713_000, 0)
+			.saturating_add(RocksDbWeight::get().reads(1_u64))
+	}
+	/// Storage: `Pov::UnboundedValue` (r:1 w:0)
+	/// Proof: `Pov::UnboundedValue` (`max_values`: Some(1), `max_size`: None, mode: `Measured`)
+	/// Storage: `Pov::BoundedValue` (r:1 w:0)
+	/// Proof: `Pov::BoundedValue` (`max_values`: Some(1), `max_size`: Some(33), added: 528, mode: `MaxEncodedLen`)
+	fn storage_value_bounded_and_unbounded_read() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `534`
+		//  Estimated: `2019`
+		// Minimum execution time: 4_310_000 picoseconds.
+		Weight::from_parts(4_559_000, 2019)
+			.saturating_add(RocksDbWeight::get().reads(2_u64))
+	}
+	/// Storage: `Pov::LargeValue` (r:1 w:0)
+	/// Proof: `Pov::LargeValue` (`max_values`: Some(1), `max_size`: Some(4194308), added: 4194803, mode: `Measured`)
+	/// The range of component `l` is `[0, 4194304]`.
+	fn measured_storage_value_read_linear_size(l: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `13 + l * (1 ±0)`
+		//  Estimated: `1497 + l * (1 ±0)`
+		// Minimum execution time: 1_872_000 picoseconds.
+		Weight::from_parts(1_929_000, 1497)
+			// Standard Error: 132
+			.saturating_add(Weight::from_parts(11_970, 0).saturating_mul(l.into()))
+			.saturating_add(RocksDbWeight::get().reads(1_u64))
+			.saturating_add(Weight::from_parts(0, 1).saturating_mul(l.into()))
+	}
+	/// Storage: `Pov::LargeValue` (r:1 w:0)
+	/// Proof: `Pov::LargeValue` (`max_values`: Some(1), `max_size`: Some(4194308), added: 4194803, mode: `MaxEncodedLen`)
+	/// The range of component `l` is `[0, 4194304]`.
+	fn mel_storage_value_read_linear_size(l: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `13 + l * (1 ±0)`
+		//  Estimated: `4195793`
+		// Minimum execution time: 1_826_000 picoseconds.
+		Weight::from_parts(1_899_000, 4195793)
+			// Standard Error: 135
+			.saturating_add(Weight::from_parts(12_037, 0).saturating_mul(l.into()))
+			.saturating_add(RocksDbWeight::get().reads(1_u64))
+	}
+	/// Storage: `Pov::LargeValue` (r:1 w:0)
+	/// Proof: `Pov::LargeValue` (`max_values`: Some(1), `max_size`: Some(4194308), added: 4194803, mode: `Measured`)
+	/// Storage: `Pov::LargeValue2` (r:1 w:0)
+	/// Proof: `Pov::LargeValue2` (`max_values`: Some(1), `max_size`: Some(4194308), added: 4194803, mode: `Measured`)
+	/// The range of component `l` is `[0, 4194304]`.
+	fn measured_storage_double_value_read_linear_size(l: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `46 + l * (2 ±0)`
+		//  Estimated: `1530 + l * (2 ±0)`
+		// Minimum execution time: 3_663_000 picoseconds.
+		Weight::from_parts(3_837_000, 1530)
+			// Standard Error: 265
+			.saturating_add(Weight::from_parts(23_779, 0).saturating_mul(l.into()))
+			.saturating_add(RocksDbWeight::get().reads(2_u64))
+			.saturating_add(Weight::from_parts(0, 2).saturating_mul(l.into()))
+	}
+	/// Storage: `Pov::LargeValue` (r:1 w:0)
+	/// Proof: `Pov::LargeValue` (`max_values`: Some(1), `max_size`: Some(4194308), added: 4194803, mode: `MaxEncodedLen`)
+	/// Storage: `Pov::LargeValue2` (r:1 w:0)
+	/// Proof: `Pov::LargeValue2` (`max_values`: Some(1), `max_size`: Some(4194308), added: 4194803, mode: `MaxEncodedLen`)
+	/// The range of component `l` is `[0, 4194304]`.
+	fn mel_storage_double_value_read_linear_size(l: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `46 + l * (2 ±0)`
+		//  Estimated: `4195793`
+		// Minimum execution time: 3_717_000 picoseconds.
+		Weight::from_parts(3_763_000, 4195793)
+			// Standard Error: 265
+			.saturating_add(Weight::from_parts(23_782, 0).saturating_mul(l.into()))
+			.saturating_add(RocksDbWeight::get().reads(2_u64))
+	}
+	/// Storage: `Pov::LargeValue` (r:1 w:0)
+	/// Proof: `Pov::LargeValue` (`max_values`: Some(1), `max_size`: Some(4194308), added: 4194803, mode: `MaxEncodedLen`)
+	/// Storage: `Pov::LargeValue2` (r:1 w:0)
+	/// Proof: `Pov::LargeValue2` (`max_values`: Some(1), `max_size`: Some(4194308), added: 4194803, mode: `Measured`)
+	/// The range of component `l` is `[0, 4194304]`.
+	fn mel_mixed_storage_double_value_read_linear_size(l: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `46 + l * (2 ±0)`
+		//  Estimated: `4195793 + l * (2 ±0)`
+		// Minimum execution time: 3_720_000 picoseconds.
+		Weight::from_parts(3_809_000, 4195793)
+			// Standard Error: 266
+			.saturating_add(Weight::from_parts(23_788, 0).saturating_mul(l.into()))
+			.saturating_add(RocksDbWeight::get().reads(2_u64))
+			.saturating_add(Weight::from_parts(0, 2).saturating_mul(l.into()))
+	}
+	/// Storage: `Pov::LargeValue` (r:1 w:0)
+	/// Proof: `Pov::LargeValue` (`max_values`: Some(1), `max_size`: Some(4194308), added: 4194803, mode: `Measured`)
+	/// Storage: `Pov::LargeValue2` (r:1 w:0)
+	/// Proof: `Pov::LargeValue2` (`max_values`: Some(1), `max_size`: Some(4194308), added: 4194803, mode: `MaxEncodedLen`)
+	/// The range of component `l` is `[0, 4194304]`.
+	fn measured_mixed_storage_double_value_read_linear_size(l: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `46 + l * (2 ±0)`
+		//  Estimated: `4195793 + l * (2 ±0)`
+		// Minimum execution time: 3_660_000 picoseconds.
+		Weight::from_parts(3_792_000, 4195793)
+			// Standard Error: 266
+			.saturating_add(Weight::from_parts(23_795, 0).saturating_mul(l.into()))
+			.saturating_add(RocksDbWeight::get().reads(2_u64))
+			.saturating_add(Weight::from_parts(0, 2).saturating_mul(l.into()))
+	}
+	/// Storage: `Pov::UnboundedMap` (r:1 w:0)
+	/// Proof: `Pov::UnboundedMap` (`max_values`: None, `max_size`: None, mode: `Measured`)
+	/// Storage: `Pov::UnboundedMap2` (r:1 w:0)
+	/// Proof: `Pov::UnboundedMap2` (`max_values`: None, `max_size`: None, mode: `Measured`)
+	/// The range of component `i` is `[0, 1000]`.
+	fn storage_map_unbounded_both_measured_read(i: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `104 + i * (8 ±0)`
+		//  Estimated: `3568 + i * (8 ±0)`
+		// Minimum execution time: 7_143_000 picoseconds.
+		Weight::from_parts(7_945_447, 3568)
+			// Standard Error: 27
+			.saturating_add(Weight::from_parts(2_983, 0).saturating_mul(i.into()))
+			.saturating_add(RocksDbWeight::get().reads(2_u64))
+			.saturating_add(Weight::from_parts(0, 8).saturating_mul(i.into()))
+	}
+	/// Storage: `Pov::Map1M` (r:1 w:0)
+	/// Proof: `Pov::Map1M` (`max_values`: Some(1000000), `max_size`: Some(36), added: 2511, mode: `MaxEncodedLen`)
+	/// Storage: `Pov::UnboundedMap` (r:1 w:0)
+	/// Proof: `Pov::UnboundedMap` (`max_values`: None, `max_size`: None, mode: `Measured`)
+	/// The range of component `i` is `[0, 1000]`.
+	fn storage_map_partial_unbounded_read(i: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `103 + i * (4 ±0)`
+		//  Estimated: `3567 + i * (4 ±0)`
+		// Minimum execution time: 7_254_000 picoseconds.
+		Weight::from_parts(7_919_811, 3567)
+			// Standard Error: 22
+			.saturating_add(Weight::from_parts(1_670, 0).saturating_mul(i.into()))
+			.saturating_add(RocksDbWeight::get().reads(2_u64))
+			.saturating_add(Weight::from_parts(0, 4).saturating_mul(i.into()))
+	}
+	/// Storage: `Pov::Map1M` (r:1 w:0)
+	/// Proof: `Pov::Map1M` (`max_values`: Some(1000000), `max_size`: Some(36), added: 2511, mode: `MaxEncodedLen`)
+	/// Storage: `Pov::UnboundedMap` (r:1 w:0)
+	/// Proof: `Pov::UnboundedMap` (`max_values`: None, `max_size`: None, mode: `Ignored`)
+	/// The range of component `i` is `[0, 1000]`.
+	fn storage_map_partial_unbounded_ignored_read(i: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `103 + i * (4 ±0)`
+		//  Estimated: `3501 + i * (4 ±0)`
+		// Minimum execution time: 7_195_000 picoseconds.
+		Weight::from_parts(7_998_073, 3501)
+			// Standard Error: 23
+			.saturating_add(Weight::from_parts(1_576, 0).saturating_mul(i.into()))
+			.saturating_add(RocksDbWeight::get().reads(2_u64))
+			.saturating_add(Weight::from_parts(0, 4).saturating_mul(i.into()))
+	}
+	fn emit_event() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0`
+		//  Estimated: `0`
+		// Minimum execution time: 3_961_000 picoseconds.
+		Weight::from_parts(4_092_000, 0)
+	}
+	fn noop() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0`
+		//  Estimated: `0`
+		// Minimum execution time: 1_607_000 picoseconds.
+		Weight::from_parts(1_673_000, 0)
+	}
+	/// Storage: `Pov::UnboundedMapTwox` (r:65001 w:0)
+	/// Proof: `Pov::UnboundedMapTwox` (`max_values`: None, `max_size`: None, mode: `Measured`)
+	fn storage_iteration() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `17985119`
+		//  Estimated: `178863584`
+		// Minimum execution time: 305_702_942_000 picoseconds.
+		Weight::from_parts(311_508_079_000, 178863584)
+			.saturating_add(RocksDbWeight::get().reads(65001_u64))
+	}
+	/// Storage: UNKNOWN KEY `0x6b657932` (r:0 w:1)
+	/// Proof: UNKNOWN KEY `0x6b657932` (r:0 w:1)
+	/// The range of component `i` is `[0, 10]`.
+	fn storage_root_is_the_same_every_time(_i: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0`
+		//  Estimated: `0`
+		// Minimum execution time: 359_000 picoseconds.
+		Weight::from_parts(422_427, 0)
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+	}
+}