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/support/src/inherent.rs

@@ -0,0 +1,96 @@
+// 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.
+
+pub use pezsp_inherents::{
+	CheckInherentsResult, InherentData, InherentIdentifier, IsFatalError, MakeFatalError,
+};
+
+/// A pallet that provides or verifies an inherent extrinsic will implement this trait.
+///
+/// The pallet may provide an inherent, verify an inherent, or both provide and verify.
+///
+/// Briefly, inherent extrinsics ("inherents") are extrinsics that are added to a block by the block
+/// producer. See [`pezsp_inherents`] for more documentation on inherents.
+pub trait ProvideInherent {
+	/// The call type of the pallet.
+	type Call;
+	/// The error returned by `check_inherent`.
+	type Error: codec::Encode + IsFatalError;
+	/// The inherent identifier used by this inherent.
+	const INHERENT_IDENTIFIER: self::InherentIdentifier;
+
+	/// Create an inherent out of the given `InherentData`.
+	///
+	/// NOTE: All checks necessary to ensure that the inherent is correct and that can be done in
+	/// the runtime should happen in the returned `Call`.
+	/// E.g. if this provides the timestamp, the call will check that the given timestamp is
+	/// increasing the old timestamp by more than a minimum and it will also check that the
+	/// timestamp hasn't already been set in the current block.
+	fn create_inherent(data: &InherentData) -> Option<Self::Call>;
+
+	/// Determines whether this inherent is required in this block.
+	///
+	/// - `Ok(None)` indicates that this inherent is not required in this block. The default
+	/// implementation returns this.
+	///
+	/// - `Ok(Some(e))` indicates that this inherent is required in this block. `construct_runtime!`
+	/// will call this function in its implementation of `fn check_extrinsics`.
+	/// If the inherent is not present, it will return `e`.
+	///
+	/// - `Err(_)` indicates that this function failed and further operations should be aborted.
+	///
+	/// NOTE: If the inherent is required then the runtime asserts that the block contains at least
+	/// one inherent for which:
+	/// * type is [`Self::Call`],
+	/// * [`Self::is_inherent`] returns true.
+	///
+	/// NOTE: This is currently only checked by block producers, not all full nodes.
+	fn is_inherent_required(_: &InherentData) -> Result<Option<Self::Error>, Self::Error> {
+		Ok(None)
+	}
+
+	/// Check whether the given inherent is valid. Checking the inherent is optional and can be
+	/// omitted by using the default implementation.
+	///
+	/// When checking an inherent, the first parameter represents the inherent that is actually
+	/// included in the block by its author. Whereas the second parameter represents the inherent
+	/// data that the verifying node calculates.
+	///
+	/// This is intended to allow for checks that cannot be done within the runtime such as, e.g.,
+	/// the timestamp.
+	///
+	/// # Warning
+	///
+	/// This check is not guaranteed to be run by all full nodes and cannot be relied upon for
+	/// ensuring that the block is correct.
+	fn check_inherent(_: &Self::Call, _: &InherentData) -> Result<(), Self::Error> {
+		Ok(())
+	}
+
+	/// Return whether the call is an inherent call.
+	///
+	/// NOTE: Signed extrinsics are not inherents, but a signed extrinsic with the given call
+	/// variant can be dispatched.
+	///
+	/// # Warning
+	///
+	/// In FRAME, inherents are enforced to be executed before other extrinsics. For this reason,
+	/// pallets with unsigned transactions **must ensure** that no unsigned transaction call
+	/// is an inherent call, when implementing `ValidateUnsigned::validate_unsigned`.
+	/// Otherwise block producers can produce invalid blocks by including them after non inherents.
+	fn is_inherent(call: &Self::Call) -> bool;
+}