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/timestamp/src/benchmarking.rs

@@ -0,0 +1,76 @@
+// 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.
+
+//! Timestamp pallet benchmarking.
+
+#![cfg(feature = "runtime-benchmarks")]
+
+use pezframe_benchmarking::{benchmarking::add_to_whitelist, v2::*};
+use pezframe_support::traits::OnFinalize;
+use pezframe_system::RawOrigin;
+use pezsp_storage::TrackedStorageKey;
+
+use crate::*;
+
+const MAX_TIME: u32 = 100;
+
+#[benchmarks]
+mod benchmarks {
+	use super::*;
+
+	#[benchmark]
+	fn set() {
+		let t = MAX_TIME;
+		// Ignore write to `DidUpdate` since it transient.
+		let did_update_key = DidUpdate::<T>::hashed_key().to_vec();
+		add_to_whitelist(TrackedStorageKey {
+			key: did_update_key,
+			reads: 0,
+			writes: 1,
+			whitelisted: false,
+		});
+
+		#[extrinsic_call]
+		_(RawOrigin::None, t.into());
+
+		assert_eq!(Now::<T>::get(), t.into(), "Time was not set.");
+	}
+
+	#[benchmark]
+	fn on_finalize() {
+		let t = MAX_TIME;
+		Pallet::<T>::set(RawOrigin::None.into(), t.into()).unwrap();
+		assert!(DidUpdate::<T>::exists(), "Time was not set.");
+
+		// Ignore read/write to `DidUpdate` since it is transient.
+		let did_update_key = DidUpdate::<T>::hashed_key().to_vec();
+		add_to_whitelist(did_update_key.into());
+
+		#[block]
+		{
+			Pallet::<T>::on_finalize(t.into());
+		}
+
+		assert!(!DidUpdate::<T>::exists(), "Time was not removed.");
+	}
+
+	impl_benchmark_test_suite! {
+		Pallet,
+		mock::new_test_ext(),
+		mock::Test
+	}
+}

bizinikiwi/pezframe/timestamp/src/lib.rs

@@ -0,0 +1,380 @@
+// 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.
+
+//! > Made with *Bizinikiwi*, for *Pezkuwi*.
+//!
+//! [![github]](https://github.com/pezkuwichain/pezkuwi-sdk/bizinikiwi/pezframe/timestamp)
+//! [![pezkuwi]](https://pezkuwichain.io)
+//!
+//! [pezkuwi]: https://img.shields.io/badge/polkadot-E6007A?style=for-the-badge&logo=polkadot&logoColor=white
+//! [github]: https://img.shields.io/badge/github-8da0cb?style=for-the-badge&labelColor=555555&logo=github
+//!
+//! # Timestamp Pallet
+//!
+//! A pallet that provides a way for consensus systems to set and check the onchain time.
+//!
+//! ## Pallet API
+//!
+//! See the [`pallet`] module for more information about the interfaces this pallet exposes,
+//! including its configuration trait, dispatchables, storage items, events and errors.
+//!
+//! ## Overview
+//!
+//! The Timestamp pallet is designed to create a consensus-based time source. This helps ensure that
+//! nodes maintain a synchronized view of time that all network participants can agree on.
+//!
+//! It defines an _acceptable range_ using a configurable constant to specify how much time must
+//! pass before setting the new timestamp. Validator nodes in the network must verify that the
+//! timestamp falls within this acceptable range and reject blocks that do not.
+//!
+//! > **Note:** The timestamp set by this pallet is the recommended way to query the onchain time
+//! > instead of using block numbers alone. Measuring time with block numbers can cause cumulative
+//! > calculation errors if depended upon in time critical operations and hence should generally be
+//! > avoided.
+//!
+//! ## Example
+//!
+//! To get the current time for the current block in another pallet:
+//!
+//! ```
+//! use pezpallet_timestamp::{self as timestamp};
+//!
+//! #[pezframe_support::pallet]
+//! pub mod pallet {
+//! 	use super::*;
+//! 	use pezframe_support::pezpallet_prelude::*;
+//! 	use pezframe_system::pezpallet_prelude::*;
+//!
+//! 	#[pallet::pallet]
+//! 	pub struct Pallet<T>(_);
+//!
+//! 	#[pallet::config]
+//! 	pub trait Config: pezframe_system::Config + timestamp::Config {}
+//!
+//! 	#[pallet::call]
+//! 	impl<T: Config> Pallet<T> {
+//! 		#[pallet::weight(0)]
+//! 		pub fn get_time(origin: OriginFor<T>) -> DispatchResult {
+//! 			let _sender = ensure_signed(origin)?;
+//! 			let _now = timestamp::Pallet::<T>::get();
+//! 			Ok(())
+//! 		}
+//! 	}
+//! }
+//! # fn main() {}
+//! ```
+//!
+//!  If [`Pallet::get`] is called prior to setting the timestamp, it will return the timestamp of
+//! the previous block.
+//!
+//! ## Low Level / Implementation Details
+//!
+//! A timestamp is added to the chain using an _inherent extrinsic_ that only a block author can
+//! submit. Inherents are a special type of extrinsic in Bizinikiwi chains that will always be
+//! included in a block.
+//!
+//! To provide inherent data to the runtime, this pallet implements
+//! [`ProvideInherent`](pezframe_support::inherent::ProvideInherent). It will only create an inherent
+//! if the [`Call::set`] dispatchable is called, using the
+//! [`inherent`](pezframe_support::pezpallet_macros::inherent) macro which enables validator nodes to call
+//! into the runtime to check that the timestamp provided is valid.
+//! The implementation of [`ProvideInherent`](pezframe_support::inherent::ProvideInherent) specifies a
+//! constant called `MAX_TIMESTAMP_DRIFT_MILLIS` which is used to determine the acceptable range for
+//! a valid timestamp. If a block author sets a timestamp to anything that is more than this
+//! constant, a validator node will reject the block.
+//!
+//! The pallet also ensures that a timestamp is set at the start of each block by running an
+//! assertion in the `on_finalize` runtime hook. See [`pezframe_support::traits::Hooks`] for more
+//! information about how hooks work.
+//!
+//! Because inherents are applied to a block in the order they appear in the runtime
+//! construction, the index of this pallet in
+//! [`construct_runtime`](pezframe_support::construct_runtime) must always be less than any other
+//! pallet that depends on it.
+//!
+//! The [`Config::OnTimestampSet`] configuration trait can be set to another pallet we want to
+//! notify that the timestamp has been updated, as long as it implements [`OnTimestampSet`].
+//! Examples are the Babe and Aura pallets.
+//! This pallet also implements [`Time`] and [`UnixTime`] so it can be used to configure other
+//! pallets that require these types (e.g. in Staking pallet).
+//!
+//! ## Panics
+//!
+//! There are 3 cases where this pallet could cause the runtime to panic.
+//!
+//! 1. If no timestamp is set at the end of a block.
+//!
+//! 2. If a timestamp is set more than once per block:
+#![doc = docify::embed!("src/tests.rs", double_timestamp_should_fail)]
+//!
+//! 3. If a timestamp is set before the [`Config::MinimumPeriod`] is elapsed:
+#![doc = docify::embed!("src/tests.rs", block_period_minimum_enforced)]
+#![deny(missing_docs)]
+#![cfg_attr(not(feature = "std"), no_std)]
+
+mod benchmarking;
+#[cfg(test)]
+mod mock;
+#[cfg(test)]
+mod tests;
+pub mod weights;
+
+use core::{cmp, result};
+use pezframe_support::traits::{OnTimestampSet, Time, UnixTime};
+use pezsp_runtime::traits::{AtLeast32Bit, SaturatedConversion, Scale, Zero};
+use pezsp_timestamp::{InherentError, InherentType, INHERENT_IDENTIFIER};
+pub use weights::WeightInfo;
+
+pub use pallet::*;
+
+#[pezframe_support::pallet]
+pub mod pallet {
+	use super::*;
+	use pezframe_support::{derive_impl, pezpallet_prelude::*};
+	use pezframe_system::pezpallet_prelude::*;
+
+	/// Default preludes for [`Config`].
+	pub mod config_preludes {
+		use super::*;
+
+		/// Default prelude sensible to be used in a testing environment.
+		pub struct TestDefaultConfig;
+
+		#[derive_impl(pezframe_system::config_preludes::TestDefaultConfig, no_aggregated_types)]
+		impl pezframe_system::DefaultConfig for TestDefaultConfig {}
+
+		#[pezframe_support::register_default_impl(TestDefaultConfig)]
+		impl DefaultConfig for TestDefaultConfig {
+			type Moment = u64;
+			type OnTimestampSet = ();
+			type MinimumPeriod = ConstUint<1>;
+			type WeightInfo = ();
+		}
+	}
+
+	/// The pallet configuration trait
+	#[pallet::config(with_default)]
+	pub trait Config: pezframe_system::Config {
+		/// Type used for expressing a timestamp.
+		#[pallet::no_default_bounds]
+		type Moment: Parameter
+			+ Default
+			+ AtLeast32Bit
+			+ Scale<BlockNumberFor<Self>, Output = Self::Moment>
+			+ Copy
+			+ MaxEncodedLen
+			+ scale_info::StaticTypeInfo;
+
+		/// Something which can be notified (e.g. another pallet) when the timestamp is set.
+		///
+		/// This can be set to `()` if it is not needed.
+		type OnTimestampSet: OnTimestampSet<Self::Moment>;
+
+		/// The minimum period between blocks.
+		///
+		/// Be aware that this is different to the *expected* period that the block production
+		/// apparatus provides. Your chosen consensus system will generally work with this to
+		/// determine a sensible block time. For example, in the Aura pallet it will be double this
+		/// period on default settings.
+		#[pallet::constant]
+		type MinimumPeriod: Get<Self::Moment>;
+
+		/// Weight information for extrinsics in this pallet.
+		type WeightInfo: WeightInfo;
+	}
+
+	#[pallet::pallet]
+	pub struct Pallet<T>(_);
+
+	/// The current time for the current block.
+	#[pallet::storage]
+	pub type Now<T: Config> = StorageValue<_, T::Moment, ValueQuery>;
+
+	/// Whether the timestamp has been updated in this block.
+	///
+	/// This value is updated to `true` upon successful submission of a timestamp by a node.
+	/// It is then checked at the end of each block execution in the `on_finalize` hook.
+	#[pallet::storage]
+	pub(super) type DidUpdate<T: Config> = StorageValue<_, bool, ValueQuery>;
+
+	#[pallet::hooks]
+	impl<T: Config> Hooks<BlockNumberFor<T>> for Pallet<T> {
+		/// A dummy `on_initialize` to return the amount of weight that `on_finalize` requires to
+		/// execute.
+		fn on_initialize(_n: BlockNumberFor<T>) -> Weight {
+			// weight of `on_finalize`
+			T::WeightInfo::on_finalize()
+		}
+
+		/// At the end of block execution, the `on_finalize` hook checks that the timestamp was
+		/// updated. Upon success, it removes the boolean value from storage. If the value resolves
+		/// to `false`, the pallet will panic.
+		///
+		/// ## Complexity
+		/// - `O(1)`
+		fn on_finalize(_n: BlockNumberFor<T>) {
+			assert!(DidUpdate::<T>::take(), "Timestamp must be updated once in the block");
+		}
+	}
+
+	#[pallet::call]
+	impl<T: Config> Pallet<T> {
+		/// Set the current time.
+		///
+		/// This call should be invoked exactly once per block. It will panic at the finalization
+		/// phase, if this call hasn't been invoked by that time.
+		///
+		/// The timestamp should be greater than the previous one by the amount specified by
+		/// [`Config::MinimumPeriod`].
+		///
+		/// The dispatch origin for this call must be _None_.
+		///
+		/// This dispatch class is _Mandatory_ to ensure it gets executed in the block. Be aware
+		/// that changing the complexity of this call could result exhausting the resources in a
+		/// block to execute any other calls.
+		///
+		/// ## Complexity
+		/// - `O(1)` (Note that implementations of `OnTimestampSet` must also be `O(1)`)
+		/// - 1 storage read and 1 storage mutation (codec `O(1)` because of `DidUpdate::take` in
+		///   `on_finalize`)
+		/// - 1 event handler `on_timestamp_set`. Must be `O(1)`.
+		#[pallet::call_index(0)]
+		#[pallet::weight((
+			T::WeightInfo::set(),
+			DispatchClass::Mandatory
+		))]
+		pub fn set(origin: OriginFor<T>, #[pallet::compact] now: T::Moment) -> DispatchResult {
+			ensure_none(origin)?;
+			assert!(!DidUpdate::<T>::exists(), "Timestamp must be updated only once in the block");
+			let prev = Now::<T>::get();
+			assert!(
+				prev.is_zero() || now >= prev + T::MinimumPeriod::get(),
+				"Timestamp must increment by at least <MinimumPeriod> between sequential blocks"
+			);
+			Now::<T>::put(now);
+			DidUpdate::<T>::put(true);
+
+			<T::OnTimestampSet as OnTimestampSet<_>>::on_timestamp_set(now);
+
+			Ok(())
+		}
+	}
+
+	/// To check the inherent is valid, we simply take the max value between the current timestamp
+	/// and the current timestamp plus the [`Config::MinimumPeriod`].
+	/// We also check that the timestamp has not already been set in this block.
+	///
+	/// ## Errors:
+	/// - [`InherentError::TooFarInFuture`]: If the timestamp is larger than the current timestamp +
+	///   minimum drift period.
+	/// - [`InherentError::TooEarly`]: If the timestamp is less than the current + minimum period.
+	#[pallet::inherent]
+	impl<T: Config> ProvideInherent for Pallet<T> {
+		type Call = Call<T>;
+		type Error = InherentError;
+		const INHERENT_IDENTIFIER: InherentIdentifier = INHERENT_IDENTIFIER;
+
+		fn create_inherent(data: &InherentData) -> Option<Self::Call> {
+			let inherent_data = data
+				.get_data::<InherentType>(&INHERENT_IDENTIFIER)
+				.expect("Timestamp inherent data not correctly encoded")
+				.expect("Timestamp inherent data must be provided");
+			let data = (*inherent_data).saturated_into::<T::Moment>();
+
+			let next_time = cmp::max(data, Now::<T>::get() + T::MinimumPeriod::get());
+			Some(Call::set { now: next_time })
+		}
+
+		fn check_inherent(
+			call: &Self::Call,
+			data: &InherentData,
+		) -> result::Result<(), Self::Error> {
+			const MAX_TIMESTAMP_DRIFT_MILLIS: pezsp_timestamp::Timestamp =
+				pezsp_timestamp::Timestamp::new(30 * 1000);
+
+			let t: u64 = match call {
+				Call::set { ref now } => (*now).saturated_into::<u64>(),
+				_ => return Ok(()),
+			};
+
+			let data = data
+				.get_data::<InherentType>(&INHERENT_IDENTIFIER)
+				.expect("Timestamp inherent data not correctly encoded")
+				.expect("Timestamp inherent data must be provided");
+
+			let minimum = (Now::<T>::get() + T::MinimumPeriod::get()).saturated_into::<u64>();
+			if t > *(data + MAX_TIMESTAMP_DRIFT_MILLIS) {
+				Err(InherentError::TooFarInFuture)
+			} else if t < minimum {
+				Err(InherentError::TooEarly)
+			} else {
+				Ok(())
+			}
+		}
+
+		fn is_inherent(call: &Self::Call) -> bool {
+			matches!(call, Call::set { .. })
+		}
+	}
+}
+
+impl<T: Config> Pallet<T> {
+	/// Get the current time for the current block.
+	///
+	/// NOTE: if this function is called prior to setting the timestamp,
+	/// it will return the timestamp of the previous block.
+	pub fn get() -> T::Moment {
+		Now::<T>::get()
+	}
+
+	/// Set the timestamp to something in particular. Only used for tests.
+	#[cfg(any(feature = "runtime-benchmarks", feature = "std"))]
+	pub fn set_timestamp(now: T::Moment) {
+		Now::<T>::put(now);
+		DidUpdate::<T>::put(true);
+		<T::OnTimestampSet as OnTimestampSet<_>>::on_timestamp_set(now);
+	}
+}
+
+impl<T: Config> Time for Pallet<T> {
+	/// A type that represents a unit of time.
+	type Moment = T::Moment;
+
+	fn now() -> Self::Moment {
+		Now::<T>::get()
+	}
+}
+
+/// Before the timestamp inherent is applied, it returns the time of previous block.
+///
+/// On genesis the time returned is not valid.
+impl<T: Config> UnixTime for Pallet<T> {
+	fn now() -> core::time::Duration {
+		// now is duration since unix epoch in millisecond as documented in
+		// `pezsp_timestamp::InherentDataProvider`.
+		let now = Now::<T>::get();
+
+		if now == T::Moment::zero() {
+			log::error!(
+				target: "runtime::timestamp",
+				"`pezpallet_timestamp::UnixTime::now` is called at genesis, invalid value returned: 0",
+			);
+		}
+
+		core::time::Duration::from_millis(now.saturated_into::<u64>())
+	}
+}

bizinikiwi/pezframe/timestamp/src/mock.rs

@@ -0,0 +1,73 @@
+// 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.
+
+//! Tests Utilities.
+
+use super::*;
+use crate as pezpallet_timestamp;
+
+use pezframe_support::{derive_impl, parameter_types, traits::ConstU64};
+use pezsp_io::TestExternalities;
+use pezsp_runtime::BuildStorage;
+
+type Block = pezframe_system::mocking::MockBlock<Test>;
+type Moment = u64;
+
+pezframe_support::construct_runtime!(
+	pub enum Test
+	{
+		System: pezframe_system,
+		Timestamp: pezpallet_timestamp,
+	}
+);
+
+#[derive_impl(pezframe_system::config_preludes::TestDefaultConfig)]
+impl pezframe_system::Config for Test {
+	type Block = Block;
+}
+
+parameter_types! {
+	pub static CapturedMoment: Option<Moment> = None;
+}
+
+pub struct MockOnTimestampSet;
+impl OnTimestampSet<Moment> for MockOnTimestampSet {
+	fn on_timestamp_set(moment: Moment) {
+		CapturedMoment::mutate(|x| *x = Some(moment));
+	}
+}
+
+impl Config for Test {
+	type Moment = Moment;
+	type OnTimestampSet = MockOnTimestampSet;
+	type MinimumPeriod = ConstU64<5>;
+	type WeightInfo = ();
+}
+
+pub(crate) fn clear_captured_moment() {
+	CapturedMoment::mutate(|x| *x = None);
+}
+
+pub(crate) fn get_captured_moment() -> Option<Moment> {
+	CapturedMoment::get()
+}
+
+pub(crate) fn new_test_ext() -> TestExternalities {
+	let t = pezframe_system::GenesisConfig::<Test>::default().build_storage().unwrap();
+	clear_captured_moment();
+	TestExternalities::new(t)
+}

bizinikiwi/pezframe/timestamp/src/tests.rs

@@ -0,0 +1,53 @@
+// 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.
+
+//! Tests for the Timestamp module.
+
+use crate::mock::*;
+use pezframe_support::assert_ok;
+
+#[test]
+fn timestamp_works() {
+	new_test_ext().execute_with(|| {
+		crate::Now::<Test>::put(46);
+		assert_ok!(Timestamp::set(RuntimeOrigin::none(), 69));
+		assert_eq!(crate::Now::<Test>::get(), 69);
+		assert_eq!(Some(69), get_captured_moment());
+	});
+}
+
+#[docify::export]
+#[test]
+#[should_panic(expected = "Timestamp must be updated only once in the block")]
+fn double_timestamp_should_fail() {
+	new_test_ext().execute_with(|| {
+		Timestamp::set_timestamp(42);
+		assert_ok!(Timestamp::set(RuntimeOrigin::none(), 69));
+	});
+}
+
+#[docify::export]
+#[test]
+#[should_panic(
+	expected = "Timestamp must increment by at least <MinimumPeriod> between sequential blocks"
+)]
+fn block_period_minimum_enforced() {
+	new_test_ext().execute_with(|| {
+		crate::Now::<Test>::put(44);
+		let _ = Timestamp::set(RuntimeOrigin::none(), 46);
+	});
+}

bizinikiwi/pezframe/timestamp/src/weights.rs

@@ -0,0 +1,126 @@
+// 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 `pezpallet_timestamp`
+//!
+//! 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=pezpallet_timestamp
+// --header=/__w/pezkuwi-sdk/pezkuwi-sdk/bizinikiwi/HEADER-APACHE2
+// --output=/__w/pezkuwi-sdk/pezkuwi-sdk/bizinikiwi/pezframe/timestamp/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 `pezpallet_timestamp`.
+pub trait WeightInfo {
+	fn set() -> Weight;
+	fn on_finalize() -> Weight;
+}
+
+/// Weights for `pezpallet_timestamp` using the Bizinikiwi node and recommended hardware.
+pub struct BizinikiwiWeight<T>(PhantomData<T>);
+impl<T: pezframe_system::Config> WeightInfo for BizinikiwiWeight<T> {
+	/// Storage: `Timestamp::Now` (r:1 w:1)
+	/// Proof: `Timestamp::Now` (`max_values`: Some(1), `max_size`: Some(8), added: 503, mode: `MaxEncodedLen`)
+	/// Storage: `Babe::CurrentSlot` (r:1 w:0)
+	/// Proof: `Babe::CurrentSlot` (`max_values`: Some(1), `max_size`: Some(8), added: 503, mode: `MaxEncodedLen`)
+	fn set() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0`
+		//  Estimated: `1493`
+		// Minimum execution time: 3_691_000 picoseconds.
+		Weight::from_parts(3_816_000, 1493)
+			.saturating_add(T::DbWeight::get().reads(2_u64))
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+	}
+	fn on_finalize() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `36`
+		//  Estimated: `0`
+		// Minimum execution time: 3_111_000 picoseconds.
+		Weight::from_parts(3_246_000, 0)
+	}
+}
+
+// For backwards compatibility and tests.
+impl WeightInfo for () {
+	/// Storage: `Timestamp::Now` (r:1 w:1)
+	/// Proof: `Timestamp::Now` (`max_values`: Some(1), `max_size`: Some(8), added: 503, mode: `MaxEncodedLen`)
+	/// Storage: `Babe::CurrentSlot` (r:1 w:0)
+	/// Proof: `Babe::CurrentSlot` (`max_values`: Some(1), `max_size`: Some(8), added: 503, mode: `MaxEncodedLen`)
+	fn set() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0`
+		//  Estimated: `1493`
+		// Minimum execution time: 3_691_000 picoseconds.
+		Weight::from_parts(3_816_000, 1493)
+			.saturating_add(RocksDbWeight::get().reads(2_u64))
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+	}
+	fn on_finalize() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `36`
+		//  Estimated: `0`
+		// Minimum execution time: 3_111_000 picoseconds.
+		Weight::from_parts(3_246_000, 0)
+	}
+}