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.

pezcumulus/teyrchains/runtimes/people/people-pezkuwichain/src/genesis_config_presets.rs

@@ -0,0 +1,213 @@
+// 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.
+
+//! # People Pezkuwichain Runtime genesis config presets
+//!
+//! This module contains genesis configuration for:
+//! - IdentityKyc: Founding citizens (founder account starts as Approved citizen)
+//! - Collator selection and session keys
+//! - Initial balance distributions
+
+use crate::*;
+use alloc::{vec, vec::Vec};
+use cumulus_primitives_core::ParaId;
+use pezframe_support::build_struct_json_patch;
+use hex_literal::hex;
+use pezsp_core::{crypto::UncheckedInto, H256};
+use pezsp_genesis_builder::PresetId;
+use pezsp_keyring::Sr25519Keyring;
+use testnet_teyrchains_constants::pezkuwichain::{
+	currency::UNITS as TYR, xcm_version::SAFE_XCM_VERSION,
+};
+use teyrchains_common::{AccountId, AuraId};
+
+const PEOPLE_PEZKUWICHAIN_ED: Balance = ExistentialDeposit::get();
+const PEOPLE_PARA_ID: ParaId = ParaId::new(1004);
+
+// ============================================================================
+// FOUNDING CITIZEN IDENTITY HASH
+// ============================================================================
+
+/// Default identity hash for founding citizens
+/// This is a placeholder hash - real citizens will update their identity through the KYC process
+/// Hash format: keccak256(json_identity_data)
+fn default_founding_citizen_identity_hash() -> H256 {
+	// A default hash representing "Genesis Founding Citizen"
+	H256::from(hex!("0000000000000000000000000000000000000000000000000000000000000001"))
+}
+
+/// Genesis configuration for People Pezkuwichain
+///
+/// # Parameters
+/// - `invulnerables`: Initial collators with their Aura keys
+/// - `endowed_accounts`: Accounts to receive initial HEZ balance
+/// - `endowment`: HEZ amount for each endowed account
+/// - `id`: Parachain ID
+/// - `founding_citizens`: Accounts that start as Approved citizens (can accept referrals)
+fn people_pezkuwichain_genesis(
+	invulnerables: Vec<(AccountId, AuraId)>,
+	endowed_accounts: Vec<AccountId>,
+	endowment: Balance,
+	id: ParaId,
+	founding_citizens: Vec<(AccountId, H256)>,
+) -> serde_json::Value {
+	build_struct_json_patch!(RuntimeGenesisConfig {
+		balances: BalancesConfig {
+			balances: endowed_accounts.iter().cloned().map(|k| (k, endowment)).collect(),
+		},
+		teyrchain_info: TeyrchainInfoConfig { teyrchain_id: id },
+		collator_selection: CollatorSelectionConfig {
+			invulnerables: invulnerables.iter().cloned().map(|(acc, _)| acc).collect(),
+			candidacy_bond: PEOPLE_PEZKUWICHAIN_ED * 16,
+		},
+		session: SessionConfig {
+			keys: invulnerables
+				.into_iter()
+				.map(|(acc, aura)| {
+					(
+						acc.clone(),          // account id
+						acc,                  // validator id
+						SessionKeys { aura }, // session keys
+					)
+				})
+				.collect(),
+		},
+		pezkuwi_xcm: PezkuwiXcmConfig { safe_xcm_version: Some(SAFE_XCM_VERSION) },
+
+		// ====================================================================
+		// IdentityKyc - Founding Citizens
+		// ====================================================================
+		// These accounts start with Approved status and can accept referrals immediately
+		// This solves the chicken-egg problem: first citizens need to exist for others to join
+		identity_kyc: IdentityKycConfig { founding_citizens, _phantom: Default::default() },
+	})
+}
+
+/// Encapsulates names of predefined presets.
+mod preset_names {
+	pub const PRESET_GENESIS: &str = "genesis";
+}
+
+/// Provides the JSON representation of predefined genesis config for given `id`.
+pub fn get_preset(id: &PresetId) -> Option<Vec<u8>> {
+	use preset_names::*;
+	let patch = match id.as_ref() {
+		// ====================================================================
+		// GENESIS PRESET - For mainnet or production use
+		// Uses hardcoded hex keys for collators
+		// Founder account is the founding citizen
+		// ====================================================================
+		PRESET_GENESIS => {
+			// Founder account - MUST be replaced with real address from
+			// Founder_treasury_presale_wallets.json before mainnet launch
+			let founder_account: AccountId =
+				hex!("44cb62d1d6cdd2fff2a5ef3bb7ef827be5b3e117a394ecaa634d8dd9809d5608").into();
+
+			people_pezkuwichain_genesis(
+				// initial collators.
+				vec![
+					// E8XC6rTJRsioKCp6KMy6zd24ykj4gWsusZ3AkSeyavpVBAG
+					(
+						hex!("44cb62d1d6cdd2fff2a5ef3bb7ef827be5b3e117a394ecaa634d8dd9809d5608")
+							.into(),
+						hex!("44cb62d1d6cdd2fff2a5ef3bb7ef827be5b3e117a394ecaa634d8dd9809d5608")
+							.unchecked_into(),
+					),
+					// G28iWEybndgGRbhfx83t7Q42YhMPByHpyqWDUgeyoGF94ri
+					(
+						hex!("9864b85e23aa4506643db9879c3dbbeabaa94d269693a4447f537dd6b5893944")
+							.into(),
+						hex!("9864b85e23aa4506643db9879c3dbbeabaa94d269693a4447f537dd6b5893944")
+							.unchecked_into(),
+					),
+					// G839e2eMiq7UXbConsY6DS1XDAYG2XnQxAmLuRLGGQ3Px9c
+					(
+						hex!("9ce5741ee2f1ac3bdedbde9f3339048f4da2cb88ddf33a0977fa0b4cf86e2948")
+							.into(),
+						hex!("9ce5741ee2f1ac3bdedbde9f3339048f4da2cb88ddf33a0977fa0b4cf86e2948")
+							.unchecked_into(),
+					),
+					// GLao4ukFUW6qhexuZowdFrKa2NLCfnEjZMftSXXfvGv1vvt
+					(
+						hex!("a676ed15f5a325eab49ed8d5f8c00f3f814b19bb58cda14ad10894c078dd337f")
+							.into(),
+						hex!("a676ed15f5a325eab49ed8d5f8c00f3f814b19bb58cda14ad10894c078dd337f")
+							.unchecked_into(),
+					),
+				],
+				Vec::new(),
+				PEOPLE_PEZKUWICHAIN_ED * 524_288,
+				PEOPLE_PARA_ID,
+				// Founding citizens: Founder starts as Approved citizen
+				vec![(founder_account, default_founding_citizen_identity_hash())],
+			)
+		},
+
+		// ====================================================================
+		// LOCAL TESTNET PRESET - For local multi-node testing (Alice + Bob)
+		// ====================================================================
+		pezsp_genesis_builder::LOCAL_TESTNET_RUNTIME_PRESET => people_pezkuwichain_genesis(
+			// initial collators.
+			vec![
+				(Sr25519Keyring::Alice.to_account_id(), Sr25519Keyring::Alice.public().into()),
+				(Sr25519Keyring::Bob.to_account_id(), Sr25519Keyring::Bob.public().into()),
+			],
+			Sr25519Keyring::well_known().map(|x| x.to_account_id()).collect(),
+			TYR * 1_000_000,
+			PEOPLE_PARA_ID,
+			// Founding citizens: Alice and Bob are founding citizens for testing
+			vec![
+				(Sr25519Keyring::Alice.to_account_id(), default_founding_citizen_identity_hash()),
+				(Sr25519Keyring::Bob.to_account_id(), default_founding_citizen_identity_hash()),
+			],
+		),
+
+		// ====================================================================
+		// DEV PRESET - For single-node development (Alice only)
+		// ====================================================================
+		pezsp_genesis_builder::DEV_RUNTIME_PRESET => people_pezkuwichain_genesis(
+			// initial collators.
+			vec![(Sr25519Keyring::Alice.to_account_id(), Sr25519Keyring::Alice.public().into())],
+			vec![
+				Sr25519Keyring::Alice.to_account_id(),
+				Sr25519Keyring::Bob.to_account_id(),
+				Sr25519Keyring::AliceStash.to_account_id(),
+				Sr25519Keyring::BobStash.to_account_id(),
+			],
+			TYR * 1_000_000,
+			PEOPLE_PARA_ID,
+			// Founding citizen: Alice is the founding citizen for dev
+			vec![(Sr25519Keyring::Alice.to_account_id(), default_founding_citizen_identity_hash())],
+		),
+
+		_ => return None,
+	};
+
+	Some(
+		serde_json::to_string(&patch)
+			.expect("serialization to json is expected to work. qed.")
+			.into_bytes(),
+	)
+}
+
+/// List of supported presets.
+pub fn preset_names() -> Vec<PresetId> {
+	use preset_names::*;
+	vec![
+		PresetId::from(PRESET_GENESIS),
+		PresetId::from(pezsp_genesis_builder::DEV_RUNTIME_PRESET),
+		PresetId::from(pezsp_genesis_builder::LOCAL_TESTNET_RUNTIME_PRESET),
+	]
+}

pezcumulus/teyrchains/runtimes/people/people-pezkuwichain/src/people.rs

@@ -0,0 +1,966 @@
+// 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.
+
+use super::*;
+use crate::xcm_config::LocationToAccountId;
+use codec::{Decode, Encode, MaxEncodedLen};
+use enumflags2::{bitflags, BitFlags};
+use pezframe_support::{
+	parameter_types,
+	traits::{ConstU32, WithdrawReasons},
+	weights::Weight,
+	CloneNoBound, EqNoBound, PartialEqNoBound, RuntimeDebugNoBound,
+};
+use pezframe_system::EnsureRoot;
+use pezpallet_identity::{Data, IdentityInformationProvider};
+use scale_info::TypeInfo;
+use pezsp_runtime::{
+	traits::{AccountIdConversion, ConvertInto, Verify},
+	RuntimeDebug,
+};
+use testnet_teyrchains_constants::pezkuwichain::currency::UNITS;
+use teyrchains_common::{impls::ToParentTreasury, DAYS, HOURS};
+
+parameter_types! {
+	//   27 | Min encoded size of `Registration`
+	// - 10 | Min encoded size of `IdentityInfo`
+	// -----|
+	//   17 | Min size without `IdentityInfo` (accounted for in byte deposit)
+	pub const BasicDeposit: Balance = deposit(1, 17);
+	pub const ByteDeposit: Balance = deposit(0, 1);
+	pub const UsernameDeposit: Balance = deposit(0, 32);
+	pub const SubAccountDeposit: Balance = deposit(1, 53);
+	pub RelayTreasuryAccount: AccountId =
+		teyrchains_common::TREASURY_PALLET_ID.into_account_truncating();
+}
+
+impl pezpallet_identity::Config for Runtime {
+	type RuntimeEvent = RuntimeEvent;
+	type Currency = Balances;
+	type BasicDeposit = BasicDeposit;
+	type ByteDeposit = ByteDeposit;
+	type UsernameDeposit = UsernameDeposit;
+	type SubAccountDeposit = SubAccountDeposit;
+	type MaxSubAccounts = ConstU32<100>;
+	type IdentityInformation = IdentityInfo;
+	type MaxRegistrars = ConstU32<20>;
+	type Slashed = ToParentTreasury<RelayTreasuryAccount, LocationToAccountId, Runtime>;
+	type ForceOrigin = EnsureRoot<Self::AccountId>;
+	type RegistrarOrigin = EnsureRoot<Self::AccountId>;
+	type OffchainSignature = Signature;
+	type SigningPublicKey = <Signature as Verify>::Signer;
+	type UsernameAuthorityOrigin = EnsureRoot<Self::AccountId>;
+	type PendingUsernameExpiration = ConstU32<{ 7 * DAYS }>;
+	type UsernameGracePeriod = ConstU32<{ 3 * DAYS }>;
+	type MaxSuffixLength = ConstU32<7>;
+	type MaxUsernameLength = ConstU32<32>;
+	#[cfg(feature = "runtime-benchmarks")]
+	type BenchmarkHelper = ();
+	type WeightInfo = weights::pezpallet_identity::WeightInfo<Runtime>;
+}
+
+/// The fields that we use to identify the owner of an account with. Each corresponds to a field
+/// in the `IdentityInfo` struct.
+#[bitflags]
+#[repr(u64)]
+#[derive(Clone, Copy, PartialEq, Eq, RuntimeDebug)]
+pub enum IdentityField {
+	Display,
+	Legal,
+	Web,
+	Matrix,
+	Email,
+	PgpFingerprint,
+	Image,
+	Twitter,
+	GitHub,
+	Discord,
+}
+
+/// Information concerning the identity of the controller of an account.
+#[derive(
+	CloneNoBound,
+	Encode,
+	Decode,
+	DecodeWithMemTracking,
+	EqNoBound,
+	MaxEncodedLen,
+	PartialEqNoBound,
+	RuntimeDebugNoBound,
+	TypeInfo,
+)]
+#[codec(mel_bound())]
+pub struct IdentityInfo {
+	/// A reasonable display name for the controller of the account. This should be whatever the
+	/// account is typically known as and should not be confusable with other entities, given
+	/// reasonable context.
+	///
+	/// Stored as UTF-8.
+	pub display: Data,
+
+	/// The full legal name in the local jurisdiction of the entity. This might be a bit
+	/// long-winded.
+	///
+	/// Stored as UTF-8.
+	pub legal: Data,
+
+	/// A representative website held by the controller of the account.
+	///
+	/// NOTE: `https://` is automatically prepended.
+	///
+	/// Stored as UTF-8.
+	pub web: Data,
+
+	/// The Matrix (e.g. for Element) handle held by the controller of the account. Previously,
+	/// this was called `riot`.
+	///
+	/// Stored as UTF-8.
+	pub matrix: Data,
+
+	/// The email address of the controller of the account.
+	///
+	/// Stored as UTF-8.
+	pub email: Data,
+
+	/// The PGP/GPG public key of the controller of the account.
+	pub pgp_fingerprint: Option<[u8; 20]>,
+
+	/// A graphic image representing the controller of the account. Should be a company,
+	/// organization or project logo or a headshot in the case of a human.
+	pub image: Data,
+
+	/// The Twitter identity. The leading `@` character may be elided.
+	pub twitter: Data,
+
+	/// The GitHub username of the controller of the account.
+	pub github: Data,
+
+	/// The Discord username of the controller of the account.
+	pub discord: Data,
+}
+
+impl IdentityInformationProvider for IdentityInfo {
+	type FieldsIdentifier = u64;
+
+	fn has_identity(&self, fields: Self::FieldsIdentifier) -> bool {
+		self.fields().bits() & fields == fields
+	}
+
+	#[cfg(feature = "runtime-benchmarks")]
+	fn create_identity_info() -> Self {
+		let data = Data::Raw(alloc::vec![0; 32].try_into().unwrap());
+
+		IdentityInfo {
+			display: data.clone(),
+			legal: data.clone(),
+			web: data.clone(),
+			matrix: data.clone(),
+			email: data.clone(),
+			pgp_fingerprint: Some([0; 20]),
+			image: data.clone(),
+			twitter: data.clone(),
+			github: data.clone(),
+			discord: data,
+		}
+	}
+
+	#[cfg(feature = "runtime-benchmarks")]
+	fn all_fields() -> Self::FieldsIdentifier {
+		use enumflags2::BitFlag;
+		IdentityField::all().bits()
+	}
+}
+
+impl IdentityInfo {
+	pub(crate) fn fields(&self) -> BitFlags<IdentityField> {
+		let mut res = <BitFlags<IdentityField>>::empty();
+		if !self.display.is_none() {
+			res.insert(IdentityField::Display);
+		}
+		if !self.legal.is_none() {
+			res.insert(IdentityField::Legal);
+		}
+		if !self.web.is_none() {
+			res.insert(IdentityField::Web);
+		}
+		if !self.matrix.is_none() {
+			res.insert(IdentityField::Matrix);
+		}
+		if !self.email.is_none() {
+			res.insert(IdentityField::Email);
+		}
+		if self.pgp_fingerprint.is_some() {
+			res.insert(IdentityField::PgpFingerprint);
+		}
+		if !self.image.is_none() {
+			res.insert(IdentityField::Image);
+		}
+		if !self.twitter.is_none() {
+			res.insert(IdentityField::Twitter);
+		}
+		if !self.github.is_none() {
+			res.insert(IdentityField::GitHub);
+		}
+		if !self.discord.is_none() {
+			res.insert(IdentityField::Discord);
+		}
+		res
+	}
+}
+
+/// A `Default` identity. This is given to users who get a username but have not set an identity.
+impl Default for IdentityInfo {
+	fn default() -> Self {
+		IdentityInfo {
+			display: Data::None,
+			legal: Data::None,
+			web: Data::None,
+			matrix: Data::None,
+			email: Data::None,
+			pgp_fingerprint: None,
+			image: Data::None,
+			twitter: Data::None,
+			github: Data::None,
+			discord: Data::None,
+		}
+	}
+}
+
+// =============================================================================
+// PezkuwiChain Custom People Pallets Configuration
+// =============================================================================
+// NOTE: These configurations are placeholders. Full implementation requires
+// additional pallet API alignment. See compile errors for specific issues.
+// =============================================================================
+
+parameter_types! {
+	/// Deposit required for KYC application (spam prevention)
+	pub const KycApplicationDeposit: Balance = UNITS; // 1 PEZ
+	/// Maximum string length for identity fields
+	pub const MaxStringLength: u32 = 128;
+	/// Maximum CID (IPFS) length
+	pub const MaxCidLength: u32 = 64;
+}
+
+/// Noop implementation for OnKycApproved hook
+pub struct OnKycApprovedHook;
+impl pezpallet_identity_kyc::types::OnKycApproved<AccountId> for OnKycApprovedHook {
+	fn on_kyc_approved(_who: &AccountId, _referrer: &AccountId) {
+		// Hook implementation - referral pallet integration
+	}
+}
+
+/// Noop implementation for OnCitizenshipRevoked hook
+pub struct OnCitizenshipRevokedHook;
+impl pezpallet_identity_kyc::types::OnCitizenshipRevoked<AccountId> for OnCitizenshipRevokedHook {
+	fn on_citizenship_revoked(_who: &AccountId) {
+		// Penalty logic can be added here
+	}
+}
+
+/// Citizen NFT provider - noop implementation for now
+pub struct CitizenNftProviderImpl;
+impl pezpallet_identity_kyc::types::CitizenNftProvider<AccountId> for CitizenNftProviderImpl {
+	fn mint_citizen_nft(_who: &AccountId) -> Result<(), pezsp_runtime::DispatchError> {
+		Ok(())
+	}
+
+	fn mint_citizen_nft_confirmed(_who: &AccountId) -> Result<(), pezsp_runtime::DispatchError> {
+		Ok(())
+	}
+
+	fn burn_citizen_nft(_who: &AccountId) -> Result<(), pezsp_runtime::DispatchError> {
+		Ok(())
+	}
+}
+
+impl pezpallet_identity_kyc::Config for Runtime {
+	type RuntimeEvent = RuntimeEvent;
+	type Currency = Balances;
+	// Kademeli yetki devri: Root → Diwan → Teknik Komisyon
+	// Vatandaşlık kararları için Divan (Anayasa Mahkemesi) yetkili
+	type GovernanceOrigin = crate::RootOrDiwanOrTechnical;
+	type WeightInfo = pezpallet_identity_kyc::weights::BizinikiwiWeight<Runtime>;
+	type OnKycApproved = OnKycApprovedHook;
+	type OnCitizenshipRevoked = OnCitizenshipRevokedHook;
+	type CitizenNftProvider = CitizenNftProviderImpl;
+	type KycApplicationDeposit = KycApplicationDeposit;
+	type MaxStringLength = MaxStringLength;
+	type MaxCidLength = MaxCidLength;
+}
+
+// =============================================================================
+// Perwerde (Education) Pallet Configuration
+// =============================================================================
+
+parameter_types! {
+	pub const MaxCourseNameLength: u32 = 128;
+	pub const MaxCourseDescLength: u32 = 512;
+	pub const MaxCourseLinkLength: u32 = 256;
+	pub const MaxStudentsPerCourse: u32 = 1000;
+	pub const MaxCoursesPerStudent: u32 = 50;
+}
+
+/// Admin origin for Perwerde pallet that supports progressive decentralization
+///
+/// Yetki devri sırası:
+/// 1. Root (Sudo) - Başlangıç aşaması
+/// 2. Council (1/2 çoğunluk) - Seçimler sonrası
+/// 3. Serok atayabilir - Cumhurbaşkanlığı yetkisi
+///
+/// Bu origin AccountId döndürür (kurs sahibi olarak kullanılır)
+pub struct PerwerdeAdminOrigin;
+impl pezframe_support::traits::EnsureOrigin<RuntimeOrigin> for PerwerdeAdminOrigin {
+	type Success = AccountId;
+	fn try_origin(o: RuntimeOrigin) -> Result<Self::Success, RuntimeOrigin> {
+		// 1. Root origin kontrolü
+		if let Ok(_) = pezframe_system::ensure_root(o.clone()) {
+			// Root için varsayılan admin hesabı
+			return Ok(pezsp_keyring::Sr25519Keyring::Alice.to_account_id());
+		}
+
+		// 2. Council kontrolü (1/2'den fazla oy)
+		if let Ok(_) = pezpallet_collective::EnsureProportionMoreThan::<
+			AccountId,
+			CouncilCollective,
+			1,
+			2,
+		>::try_origin(o.clone())
+		{
+			// Komisyon için varsayılan admin hesabı
+			return Ok(pezsp_keyring::Sr25519Keyring::Alice.to_account_id());
+		}
+
+		// 3. Serok (Cumhurbaşkanı) kontrolü
+		if let Ok(serok) = pezpallet_welati::EnsureSerok::<Runtime>::try_origin(o.clone()) {
+			return Ok(serok);
+		}
+
+		Err(o)
+	}
+
+	#[cfg(feature = "runtime-benchmarks")]
+	fn try_successful_origin() -> Result<RuntimeOrigin, ()> {
+		Ok(RuntimeOrigin::root())
+	}
+}
+
+impl pezpallet_perwerde::Config for Runtime {
+	type RuntimeEvent = RuntimeEvent;
+	type AdminOrigin = PerwerdeAdminOrigin;
+	type WeightInfo = pezpallet_perwerde::weights::BizinikiwiWeight<Runtime>;
+	type MaxCourseNameLength = MaxCourseNameLength;
+	type MaxCourseDescLength = MaxCourseDescLength;
+	type MaxCourseLinkLength = MaxCourseLinkLength;
+	type MaxStudentsPerCourse = MaxStudentsPerCourse;
+	type MaxCoursesPerStudent = MaxCoursesPerStudent;
+}
+
+// =============================================================================
+// Referral Pallet Configuration
+// =============================================================================
+
+parameter_types! {
+	/// Default referrer account (genesis/system account)
+	pub DefaultReferrer: AccountId = pezsp_keyring::Sr25519Keyring::Alice.to_account_id();
+	/// Penalty per revocation (trust score reduction)
+	pub const PenaltyPerRevocation: u32 = 10;
+}
+
+impl pezpallet_referral::Config for Runtime {
+	type RuntimeEvent = RuntimeEvent;
+	type WeightInfo = pezpallet_referral::weights::BizinikiwiWeight<Runtime>;
+	type DefaultReferrer = DefaultReferrer;
+	type PenaltyPerRevocation = PenaltyPerRevocation;
+}
+
+// =============================================================================
+// NFTs Pallet Configuration (required by Tiki)
+// =============================================================================
+
+parameter_types! {
+	pub const NftsCollectionDeposit: Balance = 10 * UNITS;
+	pub const NftsItemDeposit: Balance = UNITS / 100;
+	pub const NftsMetadataDepositBase: Balance = deposit(1, 129);
+	pub const NftsAttributeDepositBase: Balance = deposit(1, 0);
+	pub const NftsDepositPerByte: Balance = deposit(0, 1);
+	pub NftsPalletFeatures: pezpallet_nfts::PalletFeatures = pezpallet_nfts::PalletFeatures::all_enabled();
+	pub const NftsMaxDeadlineDuration: BlockNumber = 12 * 30 * DAYS;
+	pub const NftsMaxAttributesPerCall: u32 = 10;
+}
+
+impl pezpallet_nfts::Config for Runtime {
+	type RuntimeEvent = RuntimeEvent;
+	type CollectionId = u32;
+	type ItemId = u32;
+	type Currency = Balances;
+	type ForceOrigin = EnsureRoot<AccountId>;
+	type CreateOrigin =
+		pezframe_support::traits::AsEnsureOriginWithArg<pezframe_system::EnsureSigned<AccountId>>;
+	type Locker = ();
+	type CollectionDeposit = NftsCollectionDeposit;
+	type ItemDeposit = NftsItemDeposit;
+	type MetadataDepositBase = NftsMetadataDepositBase;
+	type AttributeDepositBase = NftsAttributeDepositBase;
+	type DepositPerByte = NftsDepositPerByte;
+	type StringLimit = ConstU32<256>;
+	type KeyLimit = ConstU32<64>;
+	type ValueLimit = ConstU32<256>;
+	type ApprovalsLimit = ConstU32<20>;
+	type ItemAttributesApprovalsLimit = ConstU32<30>;
+	type MaxTips = ConstU32<10>;
+	type MaxDeadlineDuration = NftsMaxDeadlineDuration;
+	type MaxAttributesPerCall = NftsMaxAttributesPerCall;
+	type Features = NftsPalletFeatures;
+	type OffchainSignature = Signature;
+	type OffchainPublic = <Signature as pezsp_runtime::traits::Verify>::Signer;
+	#[cfg(feature = "runtime-benchmarks")]
+	type Helper = ();
+	type WeightInfo = pezpallet_nfts::weights::BizinikiwiWeight<Runtime>;
+	type BlockNumberProvider = pezframe_system::Pallet<Runtime>;
+}
+
+// =============================================================================
+// Tiki (Role NFT) Pallet Configuration
+// =============================================================================
+
+parameter_types! {
+	/// Collection ID for Tiki (Role) NFTs - Collection 0 is reserved for citizenship/roles
+	pub const TikiCollectionId: u32 = 0;
+	/// Maximum number of roles a user can hold
+	pub const MaxTikisPerUser: u32 = 20;
+}
+
+impl pezpallet_tiki::Config for Runtime {
+	type RuntimeEvent = RuntimeEvent;
+	// Kademeli yetki devri: Root → Teknik Komisyon
+	// NFT/Rol yönetimi için Teknik Komisyon yetkili
+	type AdminOrigin = crate::RootOrTechnicalCommittee;
+	type WeightInfo = pezpallet_tiki::weights::BizinikiwiWeight<Runtime>;
+	type TikiCollectionId = TikiCollectionId;
+	type MaxTikisPerUser = MaxTikisPerUser;
+	type Tiki = pezpallet_tiki::Tiki;
+}
+
+// =============================================================================
+// Staking Score Pallet Configuration
+// =============================================================================
+
+parameter_types! {
+	/// Update interval for staking scores (blocks)
+	pub const StakingScoreUpdateInterval: BlockNumber = HOURS;
+}
+
+/// Staking info provider - noop implementation for People parachain
+/// On People chain, we don't have direct access to staking info from relay chain.
+/// This is a placeholder that returns None, meaning users won't get staking-based scores here.
+#[cfg(not(feature = "runtime-benchmarks"))]
+pub struct StakingInfoProvider;
+#[cfg(not(feature = "runtime-benchmarks"))]
+impl pezpallet_staking_score::StakingInfoProvider<AccountId, Balance> for StakingInfoProvider {
+	fn get_staking_details(
+		_who: &AccountId,
+	) -> Option<pezpallet_staking_score::StakingDetails<Balance>> {
+		// People parachain doesn't have direct staking - return None
+		None
+	}
+}
+
+/// Mock staking info provider for benchmarking - always returns valid stake
+#[cfg(feature = "runtime-benchmarks")]
+pub struct StakingInfoProvider;
+#[cfg(feature = "runtime-benchmarks")]
+impl pezpallet_staking_score::StakingInfoProvider<AccountId, Balance> for StakingInfoProvider {
+	fn get_staking_details(
+		_who: &AccountId,
+	) -> Option<pezpallet_staking_score::StakingDetails<Balance>> {
+		// Return mock staking data for benchmarks
+		Some(pezpallet_staking_score::StakingDetails {
+			staked_amount: 1_000_000_000_000_000u128, // 1000 units
+			nominations_count: 5,
+			unlocking_chunks_count: 2,
+		})
+	}
+}
+
+impl pezpallet_staking_score::Config for Runtime {
+	type RuntimeEvent = RuntimeEvent;
+	type WeightInfo = pezpallet_staking_score::weights::BizinikiwiWeight<Runtime>;
+	type Balance = Balance;
+	type StakingInfo = StakingInfoProvider;
+}
+
+// =============================================================================
+// Collective Pallet Configuration (for governance)
+// =============================================================================
+//
+// Pezkuwichain Komisyon Yapısı:
+// - Council (Instance1): Genel Konsey - Ana yönetişim organı
+//
+// Ek komisyonlar (EducationCommittee, TechnicalCommittee, TreasuryCommittee)
+// runtime upgrade ile eklenecek. Şu an Welati pallet'in EnsureSerok,
+// EnsureParlementer ve EnsureDiwan origin'leri kullanılıyor.
+//
+// Bu komisyonlar başlangıçta Root (Sudo) tarafından yönetilir.
+// Welati pallet'i aracılığıyla seçimler yapıldığında yetki devredilir.
+// =============================================================================
+
+parameter_types! {
+	pub const CouncilMotionDuration: BlockNumber = 7 * DAYS;
+	pub const CouncilMaxProposals: u32 = 100;
+	pub const CouncilMaxMembers: u32 = 100;
+	pub MaxProposalWeight: Weight = pezsp_runtime::Perbill::from_percent(50) * RuntimeBlockWeights::get().max_block;
+}
+
+// Instance tanımları
+pub type CouncilCollective = pezpallet_collective::Instance1;
+
+/// Council (Genel Konsey) - Ana yönetişim organı
+impl pezpallet_collective::Config<CouncilCollective> for Runtime {
+	type RuntimeOrigin = RuntimeOrigin;
+	type Proposal = RuntimeCall;
+	type RuntimeEvent = RuntimeEvent;
+	type MotionDuration = CouncilMotionDuration;
+	type MaxProposals = CouncilMaxProposals;
+	type MaxMembers = CouncilMaxMembers;
+	type DefaultVote = pezpallet_collective::PrimeDefaultVote;
+	type WeightInfo = pezpallet_collective::weights::BizinikiwiWeight<Runtime>;
+	type SetMembersOrigin = EnsureRoot<AccountId>;
+	type MaxProposalWeight = MaxProposalWeight;
+	type DisapproveOrigin = EnsureRoot<AccountId>;
+	type KillOrigin = EnsureRoot<AccountId>;
+	type Consideration = ();
+}
+
+// =============================================================================
+// Trust Score Pallet Configuration
+// =============================================================================
+
+parameter_types! {
+	/// Base multiplier for trust score calculation
+	pub const ScoreMultiplierBase: u128 = 100;
+	/// Update interval for trust scores (roughly 1 day in blocks)
+	pub const TrustUpdateInterval: BlockNumber = DAYS;
+	/// Maximum batch size for trust score updates
+	pub const TrustMaxBatchSize: u32 = 100;
+}
+
+/// Staking score source for Trust pallet
+/// Uses the StakingScore pallet to get composite staking scores
+pub struct StakingScoreSource;
+impl pezpallet_trust::StakingScoreProvider<AccountId, BlockNumber> for StakingScoreSource {
+	fn get_staking_score(who: &AccountId) -> (pezpallet_staking_score::RawScore, BlockNumber) {
+		// Delegate to StakingScore pallet
+		<StakingScore as pezpallet_staking_score::StakingScoreProvider<AccountId, BlockNumber>>::get_staking_score(who)
+	}
+}
+
+/// Referral score source for Trust pallet
+pub struct ReferralScoreSource;
+impl pezpallet_trust::ReferralScoreProvider<AccountId> for ReferralScoreSource {
+	fn get_referral_score(who: &AccountId) -> u32 {
+		Referral::referral_count(who)
+	}
+}
+
+/// Perwerde (education) score source for Trust pallet
+pub struct PerwerdeScoreSource;
+impl pezpallet_trust::PerwerdeScoreProvider<AccountId> for PerwerdeScoreSource {
+	fn get_perwerde_score(_who: &AccountId) -> u32 {
+		0 // Placeholder - Perwerde pallet integration needed
+	}
+}
+
+/// Tiki score source for Trust pallet
+pub struct TikiScoreSource;
+impl pezpallet_trust::TikiScoreProvider<AccountId> for TikiScoreSource {
+	fn get_tiki_score(who: &AccountId) -> u32 {
+		<Tiki as pezpallet_tiki::TikiScoreProvider<AccountId>>::get_tiki_score(who)
+	}
+}
+
+/// Citizenship status source for Trust pallet - uses real IdentityKyc
+#[cfg(not(feature = "runtime-benchmarks"))]
+pub struct CitizenshipSource;
+#[cfg(not(feature = "runtime-benchmarks"))]
+impl pezpallet_trust::CitizenshipStatusProvider<AccountId> for CitizenshipSource {
+	fn is_citizen(who: &AccountId) -> bool {
+		IdentityKyc::is_citizen(who)
+	}
+}
+
+/// Mock citizenship source for benchmarks - always returns true
+#[cfg(feature = "runtime-benchmarks")]
+pub struct CitizenshipSource;
+#[cfg(feature = "runtime-benchmarks")]
+impl pezpallet_trust::CitizenshipStatusProvider<AccountId> for CitizenshipSource {
+	fn is_citizen(_who: &AccountId) -> bool {
+		// Always return true for benchmark purposes
+		true
+	}
+}
+
+impl pezpallet_trust::Config for Runtime {
+	type RuntimeEvent = RuntimeEvent;
+	type WeightInfo = pezpallet_trust::weights::BizinikiwiWeight<Runtime>;
+	type Score = u128;
+	type ScoreMultiplierBase = ScoreMultiplierBase;
+	type UpdateInterval = TrustUpdateInterval;
+	type MaxBatchSize = TrustMaxBatchSize;
+	type StakingScoreSource = StakingScoreSource;
+	type ReferralScoreSource = ReferralScoreSource;
+	type PerwerdeScoreSource = PerwerdeScoreSource;
+	type TikiScoreSource = TikiScoreSource;
+	type CitizenshipSource = CitizenshipSource;
+}
+
+// =============================================================================
+// Assets Pallet Configuration (required by PEZ Rewards)
+// =============================================================================
+
+parameter_types! {
+	pub const AssetsAssetDeposit: Balance = 10 * UNITS;
+	pub const AssetsAssetAccountDeposit: Balance = deposit(1, 16);
+	pub const AssetsApprovalDeposit: Balance = deposit(1, 20);
+	pub const AssetsStringLimit: u32 = 50;
+	pub const AssetsMetadataDepositBase: Balance = deposit(1, 68);
+	pub const AssetsMetadataDepositPerByte: Balance = deposit(0, 1);
+}
+
+impl pezpallet_assets::Config for Runtime {
+	type RuntimeEvent = RuntimeEvent;
+	type Balance = Balance;
+	type AssetId = u32;
+	type AssetIdParameter = codec::Compact<u32>;
+	type Currency = Balances;
+	type CreateOrigin =
+		pezframe_support::traits::AsEnsureOriginWithArg<pezframe_system::EnsureSigned<AccountId>>;
+	type ForceOrigin = EnsureRoot<AccountId>;
+	type AssetDeposit = AssetsAssetDeposit;
+	type AssetAccountDeposit = AssetsAssetAccountDeposit;
+	type MetadataDepositBase = AssetsMetadataDepositBase;
+	type MetadataDepositPerByte = AssetsMetadataDepositPerByte;
+	type ApprovalDeposit = AssetsApprovalDeposit;
+	type StringLimit = AssetsStringLimit;
+	type Freezer = ();
+	type Extra = ();
+	type WeightInfo = weights::pezpallet_assets::WeightInfo<Runtime>;
+	type CallbackHandle = ();
+	type RemoveItemsLimit = ConstU32<1000>;
+	type ReserveData = ();
+	type Holder = ();
+	#[cfg(feature = "runtime-benchmarks")]
+	type BenchmarkHelper = ();
+}
+
+// =============================================================================
+// Scheduler Pallet Configuration (required by Welati & Democracy)
+// =============================================================================
+
+parameter_types! {
+	pub MaximumSchedulerWeight: Weight = pezsp_runtime::Perbill::from_percent(80) * RuntimeBlockWeights::get().max_block;
+}
+
+impl pezpallet_scheduler::Config for Runtime {
+	type RuntimeEvent = RuntimeEvent;
+	type RuntimeOrigin = RuntimeOrigin;
+	type PalletsOrigin = OriginCaller;
+	type RuntimeCall = RuntimeCall;
+	type MaximumWeight = MaximumSchedulerWeight;
+	type ScheduleOrigin = EnsureRoot<AccountId>;
+	type MaxScheduledPerBlock = ConstU32<50>;
+	type WeightInfo = pezpallet_scheduler::weights::BizinikiwiWeight<Runtime>;
+	type OriginPrivilegeCmp = pezframe_support::traits::EqualPrivilegeOnly;
+	type Preimages = ();
+	type BlockNumberProvider = pezframe_system::Pallet<Runtime>;
+}
+
+// =============================================================================
+// Democracy Pallet Configuration (required by Welati)
+// =============================================================================
+
+parameter_types! {
+	pub const DemocracyLaunchPeriod: BlockNumber = 7 * DAYS;
+	pub const DemocracyVotingPeriod: BlockNumber = 7 * DAYS;
+	pub const DemocracyFastTrackVotingPeriod: BlockNumber = HOURS;
+	pub const DemocracyMinimumDeposit: Balance = 10 * UNITS;
+	pub const DemocracyEnactmentPeriod: BlockNumber = DAYS;
+	pub const DemocracyCooloffPeriod: BlockNumber = 7 * DAYS;
+	pub const DemocracyMaxVotes: u32 = 100;
+	pub const DemocracyMaxProposals: u32 = 100;
+}
+
+impl pezpallet_democracy::Config for Runtime {
+	type RuntimeEvent = RuntimeEvent;
+	type Currency = Balances;
+	type EnactmentPeriod = DemocracyEnactmentPeriod;
+	type LaunchPeriod = DemocracyLaunchPeriod;
+	type VotingPeriod = DemocracyVotingPeriod;
+	type VoteLockingPeriod = DemocracyEnactmentPeriod;
+	type MinimumDeposit = DemocracyMinimumDeposit;
+	type InstantAllowed = ConstBool<true>;
+	type FastTrackVotingPeriod = DemocracyFastTrackVotingPeriod;
+	type CooloffPeriod = DemocracyCooloffPeriod;
+	type MaxVotes = DemocracyMaxVotes;
+	type MaxProposals = DemocracyMaxProposals;
+	type MaxDeposits = ConstU32<100>;
+	type MaxBlacklisted = ConstU32<100>;
+	type ExternalOrigin = EnsureRoot<AccountId>;
+	type ExternalMajorityOrigin = EnsureRoot<AccountId>;
+	type ExternalDefaultOrigin = EnsureRoot<AccountId>;
+	type FastTrackOrigin = EnsureRoot<AccountId>;
+	type InstantOrigin = EnsureRoot<AccountId>;
+	type CancellationOrigin = EnsureRoot<AccountId>;
+	type BlacklistOrigin = EnsureRoot<AccountId>;
+	type CancelProposalOrigin = EnsureRoot<AccountId>;
+	type VetoOrigin = pezframe_system::EnsureSigned<AccountId>;
+	type Slash = ();
+	type Scheduler = Scheduler;
+	type PalletsOrigin = OriginCaller;
+	type Preimages = ();
+	type SubmitOrigin = pezframe_system::EnsureSigned<AccountId>;
+	type WeightInfo = pezpallet_democracy::weights::BizinikiwiWeight<Runtime>;
+}
+
+// =============================================================================
+// Elections Phragmen Pallet Configuration (required by Welati)
+// =============================================================================
+
+parameter_types! {
+	pub const ElectionsCandidacyBond: Balance = 10 * UNITS;
+	pub const ElectionsVotingBondBase: Balance = UNITS;
+	pub const ElectionsVotingBondFactor: Balance = UNITS / 10;
+	pub const ElectionsDesiredMembers: u32 = 13;
+	pub const ElectionsDesiredRunnersUp: u32 = 7;
+	pub const ElectionsTermDuration: BlockNumber = 7 * DAYS;
+	pub const ElectionsPalletId: pezframe_support::traits::LockIdentifier = *b"phrelect";
+}
+
+impl pezpallet_elections_phragmen::Config for Runtime {
+	type RuntimeEvent = RuntimeEvent;
+	type Currency = Balances;
+	type PalletId = ElectionsPalletId;
+	type ChangeMembers = ();
+	type InitializeMembers = ();
+	type CurrencyToVote = pezsp_staking::currency_to_vote::U128CurrencyToVote;
+	type CandidacyBond = ElectionsCandidacyBond;
+	type VotingBondBase = ElectionsVotingBondBase;
+	type VotingBondFactor = ElectionsVotingBondFactor;
+	type LoserCandidate = ();
+	type KickedMember = ();
+	type DesiredMembers = ElectionsDesiredMembers;
+	type DesiredRunnersUp = ElectionsDesiredRunnersUp;
+	type TermDuration = ElectionsTermDuration;
+	type MaxCandidates = ConstU32<64>;
+	type MaxVoters = ConstU32<512>;
+	type MaxVotesPerVoter = ConstU32<16>;
+	type WeightInfo = pezpallet_elections_phragmen::weights::BizinikiwiWeight<Runtime>;
+}
+
+// =============================================================================
+// Welati (Governance) Pallet Configuration
+// =============================================================================
+
+parameter_types! {
+	/// Parliament size (201 members like Kurdistan Parliament)
+	pub const WelatiParliamentSize: u32 = 201;
+	/// Diwan council size
+	pub const WelatiDiwanSize: u32 = 50;
+	/// Election period (~4 months = ~120 days)
+	pub const WelatiElectionPeriod: BlockNumber = 120 * DAYS;
+	/// Candidacy period (~3 days)
+	pub const WelatiCandidacyPeriod: BlockNumber = 3 * DAYS;
+	/// Campaign period (~10 days)
+	pub const WelatiCampaignPeriod: BlockNumber = 10 * DAYS;
+	/// Number of electoral districts
+	pub const WelatiElectoralDistricts: u32 = 10;
+	/// Candidacy deposit (100 PEZ)
+	pub const WelatiCandidacyDeposit: u128 = 100 * UNITS as u128;
+	/// Presidential endorsements required
+	pub const WelatiPresidentialEndorsements: u32 = 1000;
+	/// Parliamentary endorsements required
+	pub const WelatiParliamentaryEndorsements: u32 = 100;
+}
+
+/// Randomness source for elections (using timestamp for now)
+pub struct TimestampRandomness;
+impl pezframe_support::traits::Randomness<Hash, BlockNumber> for TimestampRandomness {
+	fn random(subject: &[u8]) -> (Hash, BlockNumber) {
+		let block_number = pezframe_system::Pallet::<Runtime>::block_number();
+		let timestamp = pezpallet_timestamp::Pallet::<Runtime>::get();
+		let mut data = subject.to_vec();
+		data.extend_from_slice(&timestamp.to_le_bytes());
+		data.extend_from_slice(&block_number.to_le_bytes());
+		let hash = pezsp_core::hashing::blake2_256(&data);
+		(Hash::from(hash), block_number)
+	}
+}
+
+/// Citizen count provider for Welati
+pub struct WelatiCitizenSource;
+impl pezpallet_welati::CitizenInfo for WelatiCitizenSource {
+	fn citizen_count() -> u32 {
+		IdentityKyc::citizen_count()
+	}
+}
+
+/// Trust score source for Welati
+pub struct WelatiTrustScoreSource;
+impl pezpallet_trust::TrustScoreProvider<AccountId> for WelatiTrustScoreSource {
+	fn trust_score_of(who: &AccountId) -> u128 {
+		Trust::trust_score_of(who)
+	}
+}
+
+/// Tiki score source for Welati
+pub struct WelatiTikiScoreSource;
+impl pezpallet_tiki::TikiScoreProvider<AccountId> for WelatiTikiScoreSource {
+	fn get_tiki_score(who: &AccountId) -> u32 {
+		<Tiki as pezpallet_tiki::TikiScoreProvider<AccountId>>::get_tiki_score(who)
+	}
+}
+
+impl pezpallet_welati::Config for Runtime {
+	type RuntimeEvent = RuntimeEvent;
+	type WeightInfo = ();
+	type Randomness = TimestampRandomness;
+	type RuntimeCall = RuntimeCall;
+	type TrustScoreSource = WelatiTrustScoreSource;
+	type TikiSource = WelatiTikiScoreSource;
+	type CitizenSource = WelatiCitizenSource;
+	type KycSource = IdentityKyc;
+	type ParliamentSize = WelatiParliamentSize;
+	type DiwanSize = WelatiDiwanSize;
+	type ElectionPeriod = WelatiElectionPeriod;
+	type CandidacyPeriod = WelatiCandidacyPeriod;
+	type CampaignPeriod = WelatiCampaignPeriod;
+	type ElectoralDistricts = WelatiElectoralDistricts;
+	type CandidacyDeposit = WelatiCandidacyDeposit;
+	type PresidentialEndorsements = WelatiPresidentialEndorsements;
+	type ParliamentaryEndorsements = WelatiParliamentaryEndorsements;
+}
+
+// =============================================================================
+// PEZ Rewards Pallet Configuration
+// =============================================================================
+
+parameter_types! {
+	/// PEZ Asset ID
+	pub const PezAssetId: u32 = 1;
+	/// Incentive Pot Pallet ID
+	pub const IncentivePotId: pezframe_support::PalletId = pezframe_support::PalletId(*b"pez/incv");
+	/// Clawback recipient (QaziMuhammed account - placeholder)
+	pub ClawbackRecipient: AccountId = pezsp_keyring::Sr25519Keyring::Bob.to_account_id();
+}
+
+/// Trust score source for PEZ Rewards
+pub struct PezRewardsTrustScoreSource;
+impl pezpallet_trust::TrustScoreProvider<AccountId> for PezRewardsTrustScoreSource {
+	fn trust_score_of(who: &AccountId) -> u128 {
+		Trust::trust_score_of(who)
+	}
+}
+
+impl pezpallet_pez_rewards::Config for Runtime {
+	type Assets = Assets;
+	type PezAssetId = PezAssetId;
+	type WeightInfo = pezpallet_pez_rewards::weights::BizinikiwiWeight<Runtime>;
+	type TrustScoreSource = PezRewardsTrustScoreSource;
+	type IncentivePotId = IncentivePotId;
+	type ClawbackRecipient = ClawbackRecipient;
+	// Kademeli yetki devri: Root → Hazine Komisyonu
+	// PEZ ödül dağıtımı için Hazine Komisyonu yetkili
+	type ForceOrigin = crate::RootOrTreasuryCommittee;
+	type CollectionId = u32;
+	type ItemId = u32;
+}
+
+// =============================================================================
+// Recovery Pallet Configuration
+// =============================================================================
+
+parameter_types! {
+	pub const ConfigDepositBase: Balance = 5 * UNITS;
+	pub const FriendDepositFactor: Balance = 50 * CENTS;
+	pub const MaxFriends: u16 = 9;
+	pub const RecoveryDeposit: Balance = 5 * UNITS;
+}
+
+impl pezpallet_recovery::Config for Runtime {
+	type RuntimeEvent = RuntimeEvent;
+	type WeightInfo = ();
+	type RuntimeCall = RuntimeCall;
+	type BlockNumberProvider = System;
+	type Currency = Balances;
+	type ConfigDepositBase = ConfigDepositBase;
+	type FriendDepositFactor = FriendDepositFactor;
+	type MaxFriends = MaxFriends;
+	type RecoveryDeposit = RecoveryDeposit;
+}
+
+// =============================================================================
+// Society Pallet Configuration
+// =============================================================================
+
+parameter_types! {
+	pub const GraceStrikes: u32 = 10;
+	pub const SocietyVotingPeriod: BlockNumber = 80 * HOURS;
+	pub const ClaimPeriod: BlockNumber = 80 * HOURS;
+	pub const PeriodSpend: Balance = 500 * UNITS;
+	pub const MaxLockDuration: BlockNumber = 36 * 30 * DAYS;
+	pub const ChallengePeriod: BlockNumber = 7 * DAYS;
+	pub const MaxPayouts: u32 = 10;
+	pub const MaxBids: u32 = 10;
+	pub const SocietyPalletId: pezframe_support::PalletId = pezframe_support::PalletId(*b"py/socie");
+}
+
+impl pezpallet_society::Config for Runtime {
+	type RuntimeEvent = RuntimeEvent;
+	type PalletId = SocietyPalletId;
+	type Currency = Balances;
+	type Randomness = TimestampRandomness;
+	type GraceStrikes = GraceStrikes;
+	type PeriodSpend = PeriodSpend;
+	type VotingPeriod = SocietyVotingPeriod;
+	type ClaimPeriod = ClaimPeriod;
+	type MaxLockDuration = MaxLockDuration;
+	type FounderSetOrigin = EnsureRoot<AccountId>;
+	type ChallengePeriod = ChallengePeriod;
+	type MaxPayouts = MaxPayouts;
+	type MaxBids = MaxBids;
+	type BlockNumberProvider = System;
+	type WeightInfo = ();
+}
+
+// =============================================================================
+// Vesting Pallet Configuration
+// =============================================================================
+
+parameter_types! {
+	pub const MinVestedTransfer: Balance = UNITS;
+	pub UnvestedFundsAllowedWithdrawReasons: WithdrawReasons =
+		WithdrawReasons::except(WithdrawReasons::TRANSFER | WithdrawReasons::RESERVE);
+}
+
+impl pezpallet_vesting::Config for Runtime {
+	type RuntimeEvent = RuntimeEvent;
+	type Currency = Balances;
+	type BlockNumberToBalance = ConvertInto;
+	type MinVestedTransfer = MinVestedTransfer;
+	type WeightInfo = ();
+	type UnvestedFundsAllowedWithdrawReasons = UnvestedFundsAllowedWithdrawReasons;
+	type BlockNumberProvider = System;
+	const MAX_VESTING_SCHEDULES: u32 = 28;
+}

pezcumulus/teyrchains/runtimes/people/people-pezkuwichain/src/weights/block_weights.rs

@@ -0,0 +1,53 @@
+// This file is part of Pezcumulus.
+
+// Copyright (C) 2022 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 mod constants {
+	use pezframe_support::{
+		parameter_types,
+		weights::{constants, Weight},
+	};
+
+	parameter_types! {
+		/// Importing a block with 0 Extrinsics.
+		pub const BlockExecutionWeight: Weight =
+			Weight::from_parts(constants::WEIGHT_REF_TIME_PER_NANOS.saturating_mul(5_000_000), 0);
+	}
+
+	#[cfg(test)]
+	mod test_weights {
+		use pezframe_support::weights::constants;
+
+		/// Checks that the weight exists and is sane.
+		// NOTE: If this test fails but you are sure that the generated values are fine,
+		// you can delete it.
+		#[test]
+		fn sane() {
+			let w = super::constants::BlockExecutionWeight::get();
+
+			// At least 100 µs.
+			assert!(
+				w.ref_time() >= 100u64 * constants::WEIGHT_REF_TIME_PER_MICROS,
+				"Weight should be at least 100 µs."
+			);
+			// At most 50 ms.
+			assert!(
+				w.ref_time() <= 50u64 * constants::WEIGHT_REF_TIME_PER_MILLIS,
+				"Weight should be at most 50 ms."
+			);
+		}
+	}
+}

pezcumulus/teyrchains/runtimes/people/people-pezkuwichain/src/weights/extrinsic_weights.rs

@@ -0,0 +1,53 @@
+// This file is part of Pezcumulus.
+
+// Copyright (C) 2022 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 mod constants {
+	use pezframe_support::{
+		parameter_types,
+		weights::{constants, Weight},
+	};
+
+	parameter_types! {
+		/// Executing a NO-OP `System::remarks` Extrinsic.
+		pub const ExtrinsicBaseWeight: Weight =
+			Weight::from_parts(constants::WEIGHT_REF_TIME_PER_NANOS.saturating_mul(125_000), 0);
+	}
+
+	#[cfg(test)]
+	mod test_weights {
+		use pezframe_support::weights::constants;
+
+		/// Checks that the weight exists and is sane.
+		// NOTE: If this test fails but you are sure that the generated values are fine,
+		// you can delete it.
+		#[test]
+		fn sane() {
+			let w = super::constants::ExtrinsicBaseWeight::get();
+
+			// At least 10 µs.
+			assert!(
+				w.ref_time() >= 10u64 * constants::WEIGHT_REF_TIME_PER_MICROS,
+				"Weight should be at least 10 µs."
+			);
+			// At most 1 ms.
+			assert!(
+				w.ref_time() <= constants::WEIGHT_REF_TIME_PER_MILLIS,
+				"Weight should be at most 1 ms."
+			);
+		}
+	}
+}

pezcumulus/teyrchains/runtimes/people/people-pezkuwichain/src/weights/frame_system.rs

@@ -0,0 +1,191 @@
+// 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_system`
+//!
+//! 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: `afc679a858d4`, 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/people-pezkuwichain-runtime/people_pezkuwichain_runtime.wasm
+// --pallet=pezframe_system
+// --header=/__w/pezkuwi-sdk/pezkuwi-sdk/pezcumulus/file_header.txt
+// --output=./pezcumulus/teyrchains/runtimes/people/people-pezkuwichain/src/weights
+// --wasm-execution=compiled
+// --steps=50
+// --repeat=20
+// --heap-pages=4096
+// --no-storage-info
+// --no-min-squares
+// --no-median-slopes
+
+#![cfg_attr(rustfmt, rustfmt_skip)]
+#![allow(unused_parens)]
+#![allow(unused_imports)]
+#![allow(missing_docs)]
+
+use pezframe_support::{traits::Get, weights::Weight};
+use core::marker::PhantomData;
+
+/// Weight functions for `pezframe_system`.
+pub struct WeightInfo<T>(PhantomData<T>);
+impl<T: pezframe_system::Config> pezframe_system::WeightInfo for WeightInfo<T> {
+	/// The range of component `b` is `[0, 3932160]`.
+	fn remark(b: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0`
+		//  Estimated: `0`
+		// Minimum execution time: 2_085_000 picoseconds.
+		Weight::from_parts(2_147_000, 0)
+			.saturating_add(Weight::from_parts(0, 0))
+			// Standard Error: 120
+			.saturating_add(Weight::from_parts(10_681, 0).saturating_mul(b.into()))
+	}
+	/// The range of component `b` is `[0, 3932160]`.
+	fn remark_with_event(b: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0`
+		//  Estimated: `0`
+		// Minimum execution time: 5_538_000 picoseconds.
+		Weight::from_parts(5_833_000, 0)
+			.saturating_add(Weight::from_parts(0, 0))
+			// Standard Error: 120
+			.saturating_add(Weight::from_parts(12_003, 0).saturating_mul(b.into()))
+	}
+	/// Storage: UNKNOWN KEY `0x3a686561707061676573` (r:0 w:1)
+	/// Proof: UNKNOWN KEY `0x3a686561707061676573` (r:0 w:1)
+	fn set_heap_pages() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0`
+		//  Estimated: `0`
+		// Minimum execution time: 3_260_000 picoseconds.
+		Weight::from_parts(3_516_000, 0)
+			.saturating_add(Weight::from_parts(0, 0))
+			.saturating_add(T::DbWeight::get().writes(1))
+	}
+	/// Storage: `MultiBlockMigrations::Cursor` (r:1 w:0)
+	/// Proof: `MultiBlockMigrations::Cursor` (`max_values`: Some(1), `max_size`: Some(65550), added: 66045, mode: `MaxEncodedLen`)
+	/// Storage: `TeyrchainSystem::ValidationData` (r:1 w:0)
+	/// Proof: `TeyrchainSystem::ValidationData` (`max_values`: Some(1), `max_size`: None, mode: `Measured`)
+	/// Storage: `TeyrchainSystem::UpgradeRestrictionSignal` (r:1 w:0)
+	/// Proof: `TeyrchainSystem::UpgradeRestrictionSignal` (`max_values`: Some(1), `max_size`: None, mode: `Measured`)
+	/// Storage: `TeyrchainSystem::PendingValidationCode` (r:1 w:1)
+	/// Proof: `TeyrchainSystem::PendingValidationCode` (`max_values`: Some(1), `max_size`: None, mode: `Measured`)
+	/// Storage: `TeyrchainSystem::HostConfiguration` (r:1 w:0)
+	/// Proof: `TeyrchainSystem::HostConfiguration` (`max_values`: Some(1), `max_size`: None, mode: `Measured`)
+	/// Storage: `TeyrchainSystem::NewValidationCode` (r:0 w:1)
+	/// Proof: `TeyrchainSystem::NewValidationCode` (`max_values`: Some(1), `max_size`: None, mode: `Measured`)
+	/// Storage: `TeyrchainSystem::DidSetValidationCode` (r:0 w:1)
+	/// Proof: `TeyrchainSystem::DidSetValidationCode` (`max_values`: Some(1), `max_size`: None, mode: `Measured`)
+	fn set_code() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `169`
+		//  Estimated: `67035`
+		// Minimum execution time: 160_743_369_000 picoseconds.
+		Weight::from_parts(164_022_588_000, 0)
+			.saturating_add(Weight::from_parts(0, 67035))
+			.saturating_add(T::DbWeight::get().reads(5))
+			.saturating_add(T::DbWeight::get().writes(3))
+	}
+	/// Storage: `Skipped::Metadata` (r:0 w:0)
+	/// Proof: `Skipped::Metadata` (`max_values`: None, `max_size`: None, mode: `Measured`)
+	/// The range of component `i` is `[0, 1000]`.
+	fn set_storage(i: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0`
+		//  Estimated: `0`
+		// Minimum execution time: 2_082_000 picoseconds.
+		Weight::from_parts(2_202_000, 0)
+			.saturating_add(Weight::from_parts(0, 0))
+			// Standard Error: 2_221
+			.saturating_add(Weight::from_parts(715_536, 0).saturating_mul(i.into()))
+			.saturating_add(T::DbWeight::get().writes((1_u64).saturating_mul(i.into())))
+	}
+	/// Storage: `Skipped::Metadata` (r:0 w:0)
+	/// Proof: `Skipped::Metadata` (`max_values`: None, `max_size`: None, mode: `Measured`)
+	/// The range of component `i` is `[0, 1000]`.
+	fn kill_storage(i: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0`
+		//  Estimated: `0`
+		// Minimum execution time: 2_076_000 picoseconds.
+		Weight::from_parts(2_148_000, 0)
+			.saturating_add(Weight::from_parts(0, 0))
+			// Standard Error: 880
+			.saturating_add(Weight::from_parts(554_607, 0).saturating_mul(i.into()))
+			.saturating_add(T::DbWeight::get().writes((1_u64).saturating_mul(i.into())))
+	}
+	/// Storage: `Skipped::Metadata` (r:0 w:0)
+	/// Proof: `Skipped::Metadata` (`max_values`: None, `max_size`: None, mode: `Measured`)
+	/// The range of component `p` is `[0, 1000]`.
+	fn kill_prefix(p: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `82 + p * (69 ±0)`
+		//  Estimated: `78 + p * (70 ±0)`
+		// Minimum execution time: 4_139_000 picoseconds.
+		Weight::from_parts(4_248_000, 0)
+			.saturating_add(Weight::from_parts(0, 78))
+			// Standard Error: 1_318
+			.saturating_add(Weight::from_parts(1_312_979, 0).saturating_mul(p.into()))
+			.saturating_add(T::DbWeight::get().reads((1_u64).saturating_mul(p.into())))
+			.saturating_add(T::DbWeight::get().writes((1_u64).saturating_mul(p.into())))
+			.saturating_add(Weight::from_parts(0, 70).saturating_mul(p.into()))
+	}
+	/// Storage: `System::AuthorizedUpgrade` (r:0 w:1)
+	/// Proof: `System::AuthorizedUpgrade` (`max_values`: Some(1), `max_size`: Some(33), added: 528, mode: `MaxEncodedLen`)
+	fn authorize_upgrade() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0`
+		//  Estimated: `0`
+		// Minimum execution time: 10_114_000 picoseconds.
+		Weight::from_parts(10_379_000, 0)
+			.saturating_add(Weight::from_parts(0, 0))
+			.saturating_add(T::DbWeight::get().writes(1))
+	}
+	/// Storage: `System::AuthorizedUpgrade` (r:1 w:1)
+	/// Proof: `System::AuthorizedUpgrade` (`max_values`: Some(1), `max_size`: Some(33), added: 528, mode: `MaxEncodedLen`)
+	/// Storage: `MultiBlockMigrations::Cursor` (r:1 w:0)
+	/// Proof: `MultiBlockMigrations::Cursor` (`max_values`: Some(1), `max_size`: Some(65550), added: 66045, mode: `MaxEncodedLen`)
+	/// Storage: `TeyrchainSystem::ValidationData` (r:1 w:0)
+	/// Proof: `TeyrchainSystem::ValidationData` (`max_values`: Some(1), `max_size`: None, mode: `Measured`)
+	/// Storage: `TeyrchainSystem::UpgradeRestrictionSignal` (r:1 w:0)
+	/// Proof: `TeyrchainSystem::UpgradeRestrictionSignal` (`max_values`: Some(1), `max_size`: None, mode: `Measured`)
+	/// Storage: `TeyrchainSystem::PendingValidationCode` (r:1 w:1)
+	/// Proof: `TeyrchainSystem::PendingValidationCode` (`max_values`: Some(1), `max_size`: None, mode: `Measured`)
+	/// Storage: `TeyrchainSystem::HostConfiguration` (r:1 w:0)
+	/// Proof: `TeyrchainSystem::HostConfiguration` (`max_values`: Some(1), `max_size`: None, mode: `Measured`)
+	/// Storage: `TeyrchainSystem::NewValidationCode` (r:0 w:1)
+	/// Proof: `TeyrchainSystem::NewValidationCode` (`max_values`: Some(1), `max_size`: None, mode: `Measured`)
+	/// Storage: `TeyrchainSystem::DidSetValidationCode` (r:0 w:1)
+	/// Proof: `TeyrchainSystem::DidSetValidationCode` (`max_values`: Some(1), `max_size`: None, mode: `Measured`)
+	fn apply_authorized_upgrade() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `191`
+		//  Estimated: `67035`
+		// Minimum execution time: 163_855_657_000 picoseconds.
+		Weight::from_parts(166_326_130_000, 0)
+			.saturating_add(Weight::from_parts(0, 67035))
+			.saturating_add(T::DbWeight::get().reads(6))
+			.saturating_add(T::DbWeight::get().writes(4))
+	}
+}

pezcumulus/teyrchains/runtimes/people/people-pezkuwichain/src/weights/frame_system_extensions.rs

@@ -0,0 +1,146 @@
+// Copyright (C) Parity Technologies (UK) Ltd.
+// This file is part of Pezcumulus.
+// 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_system_extensions`
+//!
+//! THIS FILE WAS AUTO-GENERATED USING THE BIZINIKIWI BENCHMARK CLI VERSION 4.0.0-dev
+//! DATE: 2023-12-21, STEPS: `2`, REPEAT: `2`, LOW RANGE: `[]`, HIGH RANGE: `[]`
+//! WORST CASE MAP SIZE: `1000000`
+//! HOSTNAME: `gleipnir`, CPU: `AMD Ryzen 9 7900X 12-Core Processor`
+//! WASM-EXECUTION: `Compiled`, CHAIN: `Some("people-pezkuwichain-dev")`, DB CACHE: 1024
+
+// Executed Command:
+// ./target/release/pezkuwi-teyrchain
+// benchmark
+// pallet
+// --wasm-execution=compiled
+// --pallet=pezframe_system_extensions
+// --no-storage-info
+// --no-median-slopes
+// --no-min-squares
+// --extrinsic=*
+// --steps=2
+// --repeat=2
+// --json
+// --header=./pezcumulus/file_header.txt
+// --output=./pezcumulus/teyrchains/runtimes/people/people-pezkuwichain/src/weights/
+// --chain=people-pezkuwichain-dev
+
+#![cfg_attr(rustfmt, rustfmt_skip)]
+#![allow(unused_parens)]
+#![allow(unused_imports)]
+#![allow(missing_docs)]
+
+use pezframe_support::{traits::Get, weights::Weight};
+use core::marker::PhantomData;
+
+/// Weight functions for `pezframe_system_extensions`.
+pub struct WeightInfo<T>(PhantomData<T>);
+impl<T: pezframe_system::Config> pezframe_system::ExtensionsWeightInfo for WeightInfo<T> {
+	/// Storage: `System::BlockHash` (r:1 w:0)
+	/// Proof: `System::BlockHash` (`max_values`: None, `max_size`: Some(44), added: 2519, mode: `MaxEncodedLen`)
+	fn check_genesis() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `54`
+		//  Estimated: `3509`
+		// Minimum execution time: 3_637_000 picoseconds.
+		Weight::from_parts(6_382_000, 0)
+			.saturating_add(Weight::from_parts(0, 3509))
+			.saturating_add(T::DbWeight::get().reads(1))
+	}
+	/// Storage: `System::BlockHash` (r:1 w:0)
+	/// Proof: `System::BlockHash` (`max_values`: None, `max_size`: Some(44), added: 2519, mode: `MaxEncodedLen`)
+	fn check_mortality_mortal_transaction() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `92`
+		//  Estimated: `3509`
+		// Minimum execution time: 5_841_000 picoseconds.
+		Weight::from_parts(8_776_000, 0)
+			.saturating_add(Weight::from_parts(0, 3509))
+			.saturating_add(T::DbWeight::get().reads(1))
+	}
+	/// Storage: `System::BlockHash` (r:1 w:0)
+	/// Proof: `System::BlockHash` (`max_values`: None, `max_size`: Some(44), added: 2519, mode: `MaxEncodedLen`)
+	fn check_mortality_immortal_transaction() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `92`
+		//  Estimated: `3509`
+		// Minimum execution time: 5_841_000 picoseconds.
+		Weight::from_parts(8_776_000, 0)
+			.saturating_add(Weight::from_parts(0, 3509))
+			.saturating_add(T::DbWeight::get().reads(1))
+	}
+	fn check_non_zero_sender() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0`
+		//  Estimated: `0`
+		// Minimum execution time: 561_000 picoseconds.
+		Weight::from_parts(2_705_000, 0)
+			.saturating_add(Weight::from_parts(0, 0))
+	}
+	fn check_nonce() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0`
+		//  Estimated: `0`
+		// Minimum execution time: 3_316_000 picoseconds.
+		Weight::from_parts(5_771_000, 0)
+			.saturating_add(Weight::from_parts(0, 0))
+	}
+	fn check_spec_version() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0`
+		//  Estimated: `0`
+		// Minimum execution time: 511_000 picoseconds.
+		Weight::from_parts(2_575_000, 0)
+			.saturating_add(Weight::from_parts(0, 0))
+	}
+	fn check_tx_version() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0`
+		//  Estimated: `0`
+		// Minimum execution time: 501_000 picoseconds.
+		Weight::from_parts(2_595_000, 0)
+			.saturating_add(Weight::from_parts(0, 0))
+	}
+	/// Storage: `System::AllExtrinsicsLen` (r:1 w:1)
+	/// Proof: `System::AllExtrinsicsLen` (`max_values`: Some(1), `max_size`: Some(4), added: 499, mode: `MaxEncodedLen`)
+	/// Storage: `System::BlockWeight` (r:1 w:1)
+	/// Proof: `System::BlockWeight` (`max_values`: Some(1), `max_size`: Some(48), added: 543, mode: `MaxEncodedLen`)
+	fn check_weight() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `24`
+		//  Estimated: `1533`
+		// Minimum execution time: 3_687_000 picoseconds.
+		Weight::from_parts(6_192_000, 0)
+			.saturating_add(Weight::from_parts(0, 1533))
+			.saturating_add(T::DbWeight::get().reads(2))
+			.saturating_add(T::DbWeight::get().writes(2))
+	}
+	/// Storage: `System::AllExtrinsicsLen` (r:1 w:1)
+	/// Proof: `System::AllExtrinsicsLen` (`max_values`: Some(1), `max_size`: Some(4), added: 499, mode: `MaxEncodedLen`)
+	/// Storage: `System::BlockWeight` (r:1 w:1)
+	/// Proof: `System::BlockWeight` (`max_values`: Some(1), `max_size`: Some(48), added: 543, mode: `MaxEncodedLen`)
+	fn weight_reclaim() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `24`
+		//  Estimated: `1533`
+		// Minimum execution time: 3_687_000 picoseconds.
+		Weight::from_parts(6_192_000, 0)
+			.saturating_add(Weight::from_parts(0, 1533))
+			.saturating_add(T::DbWeight::get().reads(2))
+			.saturating_add(T::DbWeight::get().writes(2))
+	}
+}

pezcumulus/teyrchains/runtimes/people/people-pezkuwichain/src/weights/mod.rs

@@ -0,0 +1,45 @@
+// 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.
+
+//! Expose the auto generated weight files.
+
+pub mod block_weights;
+pub mod cumulus_pallet_teyrchain_system;
+pub mod cumulus_pallet_weight_reclaim;
+pub mod cumulus_pallet_xcmp_queue;
+pub mod extrinsic_weights;
+pub mod pezframe_system;
+pub mod pezframe_system_extensions;
+pub mod pezpallet_assets;
+pub mod pezpallet_balances;
+pub mod pezpallet_collator_selection;
+pub mod pezpallet_identity;
+pub mod pezpallet_message_queue;
+pub mod pezpallet_migrations;
+pub mod pezpallet_multisig;
+pub mod pezpallet_proxy;
+pub mod pezpallet_session;
+pub mod pezpallet_timestamp;
+pub mod pezpallet_transaction_payment;
+pub mod pezpallet_utility;
+pub mod pezpallet_xcm;
+pub mod paritydb_weights;
+pub mod pezkuwi_runtime_common_identity_migrator;
+pub mod rocksdb_weights;
+pub mod xcm;
+
+pub use block_weights::constants::BlockExecutionWeight;
+pub use extrinsic_weights::constants::ExtrinsicBaseWeight;
+pub use rocksdb_weights::constants::RocksDbWeight;

pezcumulus/teyrchains/runtimes/people/people-pezkuwichain/src/weights/pallet_assets.rs

@@ -0,0 +1,629 @@
+// 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_assets`
+//!
+//! THIS FILE WAS AUTO-GENERATED USING THE BIZINIKIWI BENCHMARK CLI VERSION 32.0.0
+//! DATE: 2025-05-18, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]`
+//! WORST CASE MAP SIZE: `1000000`
+//! HOSTNAME: `c47a012f15ca`, 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/asset-hub-pezkuwichain-runtime/asset_hub_pezkuwichain_runtime.wasm
+// --pallet=pezpallet_assets
+// --header=/__w/pezkuwi-sdk/pezkuwi-sdk/pezcumulus/file_header.txt
+// --output=./pezcumulus/teyrchains/runtimes/assets/asset-hub-pezkuwichain/src/weights
+// --wasm-execution=compiled
+// --steps=50
+// --repeat=20
+// --heap-pages=4096
+// --no-storage-info
+// --no-min-squares
+// --no-median-slopes
+
+#![cfg_attr(rustfmt, rustfmt_skip)]
+#![allow(unused_parens)]
+#![allow(unused_imports)]
+#![allow(missing_docs)]
+
+use pezframe_support::{traits::Get, weights::Weight};
+use core::marker::PhantomData;
+
+/// Weight functions for `pezpallet_assets`.
+pub struct WeightInfo<T>(PhantomData<T>);
+impl<T: pezframe_system::Config> pezpallet_assets::WeightInfo for WeightInfo<T> {
+	/// Storage: `Assets::Asset` (r:1 w:1)
+	/// Proof: `Assets::Asset` (`max_values`: None, `max_size`: Some(210), added: 2685, mode: `MaxEncodedLen`)
+	/// Storage: `Assets::NextAssetId` (r:1 w:0)
+	/// Proof: `Assets::NextAssetId` (`max_values`: Some(1), `max_size`: Some(4), added: 499, mode: `MaxEncodedLen`)
+	/// Storage: `System::Account` (r:1 w:1)
+	/// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `MaxEncodedLen`)
+	fn create() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `145`
+		//  Estimated: `3675`
+		// Minimum execution time: 26_482_000 picoseconds.
+		Weight::from_parts(27_179_000, 0)
+			.saturating_add(Weight::from_parts(0, 3675))
+			.saturating_add(T::DbWeight::get().reads(3))
+			.saturating_add(T::DbWeight::get().writes(2))
+	}
+	/// Storage: `Assets::Asset` (r:1 w:1)
+	/// Proof: `Assets::Asset` (`max_values`: None, `max_size`: Some(210), added: 2685, mode: `MaxEncodedLen`)
+	/// Storage: `Assets::NextAssetId` (r:1 w:0)
+	/// Proof: `Assets::NextAssetId` (`max_values`: Some(1), `max_size`: Some(4), added: 499, mode: `MaxEncodedLen`)
+	fn force_create() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `42`
+		//  Estimated: `3675`
+		// Minimum execution time: 11_224_000 picoseconds.
+		Weight::from_parts(11_615_000, 0)
+			.saturating_add(Weight::from_parts(0, 3675))
+			.saturating_add(T::DbWeight::get().reads(2))
+			.saturating_add(T::DbWeight::get().writes(1))
+	}
+	/// Storage: `Assets::Asset` (r:1 w:1)
+	/// Proof: `Assets::Asset` (`max_values`: None, `max_size`: Some(210), added: 2685, mode: `MaxEncodedLen`)
+	/// Storage: `AssetsFreezer::Freezes` (r:1 w:0)
+	/// Proof: `AssetsFreezer::Freezes` (`max_values`: None, `max_size`: Some(87), added: 2562, mode: `MaxEncodedLen`)
+	fn start_destroy() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `324`
+		//  Estimated: `3675`
+		// Minimum execution time: 16_018_000 picoseconds.
+		Weight::from_parts(16_859_000, 0)
+			.saturating_add(Weight::from_parts(0, 3675))
+			.saturating_add(T::DbWeight::get().reads(2))
+			.saturating_add(T::DbWeight::get().writes(1))
+	}
+	/// Storage: `Assets::Asset` (r:1 w:1)
+	/// Proof: `Assets::Asset` (`max_values`: None, `max_size`: Some(210), added: 2685, mode: `MaxEncodedLen`)
+	/// Storage: `Assets::Account` (r:1001 w:1000)
+	/// Proof: `Assets::Account` (`max_values`: None, `max_size`: Some(134), added: 2609, mode: `MaxEncodedLen`)
+	/// Storage: `AssetsFreezer::FrozenBalances` (r:1000 w:1000)
+	/// Proof: `AssetsFreezer::FrozenBalances` (`max_values`: None, `max_size`: Some(84), added: 2559, mode: `MaxEncodedLen`)
+	/// Storage: `System::Account` (r:1000 w:1000)
+	/// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `MaxEncodedLen`)
+	/// Storage: `AssetsFreezer::Freezes` (r:1000 w:1000)
+	/// Proof: `AssetsFreezer::Freezes` (`max_values`: None, `max_size`: Some(87), added: 2562, mode: `MaxEncodedLen`)
+	/// The range of component `c` is `[0, 1000]`.
+	/// The range of component `c` is `[0, 1000]`.
+	/// The range of component `c` is `[0, 1000]`.
+	fn destroy_accounts(c: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0 + c * (208 ±0)`
+		//  Estimated: `3675 + c * (2609 ±0)`
+		// Minimum execution time: 15_347_000 picoseconds.
+		Weight::from_parts(15_681_000, 0)
+			.saturating_add(Weight::from_parts(0, 3675))
+			// Standard Error: 26_239
+			.saturating_add(Weight::from_parts(25_531_130, 0).saturating_mul(c.into()))
+			.saturating_add(T::DbWeight::get().reads(2))
+			.saturating_add(T::DbWeight::get().reads((4_u64).saturating_mul(c.into())))
+			.saturating_add(T::DbWeight::get().writes(1))
+			.saturating_add(T::DbWeight::get().writes((4_u64).saturating_mul(c.into())))
+			.saturating_add(Weight::from_parts(0, 2609).saturating_mul(c.into()))
+	}
+	/// Storage: `Assets::Asset` (r:1 w:1)
+	/// Proof: `Assets::Asset` (`max_values`: None, `max_size`: Some(210), added: 2685, mode: `MaxEncodedLen`)
+	/// Storage: `Assets::Approvals` (r:1001 w:1000)
+	/// Proof: `Assets::Approvals` (`max_values`: None, `max_size`: Some(148), added: 2623, mode: `MaxEncodedLen`)
+	/// The range of component `a` is `[0, 1000]`.
+	/// The range of component `a` is `[0, 1000]`.
+	/// The range of component `a` is `[0, 1000]`.
+	fn destroy_approvals(a: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `451 + a * (86 ±0)`
+		//  Estimated: `3675 + a * (2623 ±0)`
+		// Minimum execution time: 16_411_000 picoseconds.
+		Weight::from_parts(16_761_000, 0)
+			.saturating_add(Weight::from_parts(0, 3675))
+			// Standard Error: 12_049
+			.saturating_add(Weight::from_parts(15_632_794, 0).saturating_mul(a.into()))
+			.saturating_add(T::DbWeight::get().reads(2))
+			.saturating_add(T::DbWeight::get().reads((1_u64).saturating_mul(a.into())))
+			.saturating_add(T::DbWeight::get().writes(1))
+			.saturating_add(T::DbWeight::get().writes((1_u64).saturating_mul(a.into())))
+			.saturating_add(Weight::from_parts(0, 2623).saturating_mul(a.into()))
+	}
+	/// Storage: `Assets::Asset` (r:1 w:1)
+	/// Proof: `Assets::Asset` (`max_values`: None, `max_size`: Some(210), added: 2685, mode: `MaxEncodedLen`)
+	/// Storage: `Assets::Metadata` (r:1 w:0)
+	/// Proof: `Assets::Metadata` (`max_values`: None, `max_size`: Some(140), added: 2615, mode: `MaxEncodedLen`)
+	fn finish_destroy() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `280`
+		//  Estimated: `3675`
+		// Minimum execution time: 12_979_000 picoseconds.
+		Weight::from_parts(13_512_000, 0)
+			.saturating_add(Weight::from_parts(0, 3675))
+			.saturating_add(T::DbWeight::get().reads(2))
+			.saturating_add(T::DbWeight::get().writes(1))
+	}
+	/// Storage: `Assets::Asset` (r:1 w:1)
+	/// Proof: `Assets::Asset` (`max_values`: None, `max_size`: Some(210), added: 2685, mode: `MaxEncodedLen`)
+	/// Storage: `Assets::Account` (r:1 w:1)
+	/// Proof: `Assets::Account` (`max_values`: None, `max_size`: Some(134), added: 2609, mode: `MaxEncodedLen`)
+	fn mint() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `280`
+		//  Estimated: `3675`
+		// Minimum execution time: 22_629_000 picoseconds.
+		Weight::from_parts(23_429_000, 0)
+			.saturating_add(Weight::from_parts(0, 3675))
+			.saturating_add(T::DbWeight::get().reads(2))
+			.saturating_add(T::DbWeight::get().writes(2))
+	}
+	/// Storage: `Assets::Asset` (r:1 w:1)
+	/// Proof: `Assets::Asset` (`max_values`: None, `max_size`: Some(210), added: 2685, mode: `MaxEncodedLen`)
+	/// Storage: `Assets::Account` (r:1 w:1)
+	/// Proof: `Assets::Account` (`max_values`: None, `max_size`: Some(134), added: 2609, mode: `MaxEncodedLen`)
+	/// Storage: `AssetsFreezer::FrozenBalances` (r:1 w:1)
+	/// Proof: `AssetsFreezer::FrozenBalances` (`max_values`: None, `max_size`: Some(84), added: 2559, mode: `MaxEncodedLen`)
+	/// Storage: `AssetsFreezer::Freezes` (r:1 w:1)
+	/// Proof: `AssetsFreezer::Freezes` (`max_values`: None, `max_size`: Some(87), added: 2562, mode: `MaxEncodedLen`)
+	fn burn() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `392`
+		//  Estimated: `3675`
+		// Minimum execution time: 45_871_000 picoseconds.
+		Weight::from_parts(46_802_000, 0)
+			.saturating_add(Weight::from_parts(0, 3675))
+			.saturating_add(T::DbWeight::get().reads(4))
+			.saturating_add(T::DbWeight::get().writes(4))
+	}
+	/// Storage: `Assets::Asset` (r:1 w:1)
+	/// Proof: `Assets::Asset` (`max_values`: None, `max_size`: Some(210), added: 2685, mode: `MaxEncodedLen`)
+	/// Storage: `Assets::Account` (r:2 w:2)
+	/// Proof: `Assets::Account` (`max_values`: None, `max_size`: Some(134), added: 2609, mode: `MaxEncodedLen`)
+	/// Storage: `AssetsFreezer::FrozenBalances` (r:1 w:1)
+	/// Proof: `AssetsFreezer::FrozenBalances` (`max_values`: None, `max_size`: Some(84), added: 2559, mode: `MaxEncodedLen`)
+	/// Storage: `System::Account` (r:1 w:1)
+	/// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `MaxEncodedLen`)
+	/// Storage: `AssetsFreezer::Freezes` (r:1 w:1)
+	/// Proof: `AssetsFreezer::Freezes` (`max_values`: None, `max_size`: Some(87), added: 2562, mode: `MaxEncodedLen`)
+	fn transfer() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `392`
+		//  Estimated: `6208`
+		// Minimum execution time: 56_609_000 picoseconds.
+		Weight::from_parts(58_229_000, 0)
+			.saturating_add(Weight::from_parts(0, 6208))
+			.saturating_add(T::DbWeight::get().reads(6))
+			.saturating_add(T::DbWeight::get().writes(6))
+	}
+	/// Storage: `Assets::Asset` (r:1 w:1)
+	/// Proof: `Assets::Asset` (`max_values`: None, `max_size`: Some(210), added: 2685, mode: `MaxEncodedLen`)
+	/// Storage: `Assets::Account` (r:2 w:2)
+	/// Proof: `Assets::Account` (`max_values`: None, `max_size`: Some(134), added: 2609, mode: `MaxEncodedLen`)
+	/// Storage: `AssetsFreezer::FrozenBalances` (r:1 w:0)
+	/// Proof: `AssetsFreezer::FrozenBalances` (`max_values`: None, `max_size`: Some(84), added: 2559, mode: `MaxEncodedLen`)
+	/// Storage: `System::Account` (r:1 w:1)
+	/// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `MaxEncodedLen`)
+	fn transfer_keep_alive() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `392`
+		//  Estimated: `6208`
+		// Minimum execution time: 42_947_000 picoseconds.
+		Weight::from_parts(43_748_000, 0)
+			.saturating_add(Weight::from_parts(0, 6208))
+			.saturating_add(T::DbWeight::get().reads(5))
+			.saturating_add(T::DbWeight::get().writes(4))
+	}
+	/// Storage: `Assets::Asset` (r:1 w:1)
+	/// Proof: `Assets::Asset` (`max_values`: None, `max_size`: Some(210), added: 2685, mode: `MaxEncodedLen`)
+	/// Storage: `Assets::Account` (r:2 w:2)
+	/// Proof: `Assets::Account` (`max_values`: None, `max_size`: Some(134), added: 2609, mode: `MaxEncodedLen`)
+	/// Storage: `AssetsFreezer::FrozenBalances` (r:1 w:1)
+	/// Proof: `AssetsFreezer::FrozenBalances` (`max_values`: None, `max_size`: Some(84), added: 2559, mode: `MaxEncodedLen`)
+	/// Storage: `System::Account` (r:1 w:1)
+	/// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `MaxEncodedLen`)
+	/// Storage: `AssetsFreezer::Freezes` (r:1 w:1)
+	/// Proof: `AssetsFreezer::Freezes` (`max_values`: None, `max_size`: Some(87), added: 2562, mode: `MaxEncodedLen`)
+	fn force_transfer() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `392`
+		//  Estimated: `6208`
+		// Minimum execution time: 56_609_000 picoseconds.
+		Weight::from_parts(58_589_000, 0)
+			.saturating_add(Weight::from_parts(0, 6208))
+			.saturating_add(T::DbWeight::get().reads(6))
+			.saturating_add(T::DbWeight::get().writes(6))
+	}
+	/// Storage: `Assets::Asset` (r:1 w:0)
+	/// Proof: `Assets::Asset` (`max_values`: None, `max_size`: Some(210), added: 2685, mode: `MaxEncodedLen`)
+	/// Storage: `Assets::Account` (r:1 w:1)
+	/// Proof: `Assets::Account` (`max_values`: None, `max_size`: Some(134), added: 2609, mode: `MaxEncodedLen`)
+	fn freeze() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `388`
+		//  Estimated: `3675`
+		// Minimum execution time: 16_199_000 picoseconds.
+		Weight::from_parts(16_994_000, 0)
+			.saturating_add(Weight::from_parts(0, 3675))
+			.saturating_add(T::DbWeight::get().reads(2))
+			.saturating_add(T::DbWeight::get().writes(1))
+	}
+	/// Storage: `Assets::Asset` (r:1 w:0)
+	/// Proof: `Assets::Asset` (`max_values`: None, `max_size`: Some(210), added: 2685, mode: `MaxEncodedLen`)
+	/// Storage: `Assets::Account` (r:1 w:1)
+	/// Proof: `Assets::Account` (`max_values`: None, `max_size`: Some(134), added: 2609, mode: `MaxEncodedLen`)
+	fn thaw() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `388`
+		//  Estimated: `3675`
+		// Minimum execution time: 16_107_000 picoseconds.
+		Weight::from_parts(17_102_000, 0)
+			.saturating_add(Weight::from_parts(0, 3675))
+			.saturating_add(T::DbWeight::get().reads(2))
+			.saturating_add(T::DbWeight::get().writes(1))
+	}
+	/// Storage: `Assets::Asset` (r:1 w:1)
+	/// Proof: `Assets::Asset` (`max_values`: None, `max_size`: Some(210), added: 2685, mode: `MaxEncodedLen`)
+	fn freeze_asset() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `314`
+		//  Estimated: `3675`
+		// Minimum execution time: 11_414_000 picoseconds.
+		Weight::from_parts(12_053_000, 0)
+			.saturating_add(Weight::from_parts(0, 3675))
+			.saturating_add(T::DbWeight::get().reads(1))
+			.saturating_add(T::DbWeight::get().writes(1))
+	}
+	/// Storage: `Assets::Asset` (r:1 w:1)
+	/// Proof: `Assets::Asset` (`max_values`: None, `max_size`: Some(210), added: 2685, mode: `MaxEncodedLen`)
+	fn thaw_asset() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `314`
+		//  Estimated: `3675`
+		// Minimum execution time: 11_710_000 picoseconds.
+		Weight::from_parts(12_122_000, 0)
+			.saturating_add(Weight::from_parts(0, 3675))
+			.saturating_add(T::DbWeight::get().reads(1))
+			.saturating_add(T::DbWeight::get().writes(1))
+	}
+	/// Storage: `Assets::Asset` (r:1 w:1)
+	/// Proof: `Assets::Asset` (`max_values`: None, `max_size`: Some(210), added: 2685, mode: `MaxEncodedLen`)
+	/// Storage: `Assets::Metadata` (r:1 w:0)
+	/// Proof: `Assets::Metadata` (`max_values`: None, `max_size`: Some(140), added: 2615, mode: `MaxEncodedLen`)
+	fn transfer_ownership() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `280`
+		//  Estimated: `3675`
+		// Minimum execution time: 13_447_000 picoseconds.
+		Weight::from_parts(13_861_000, 0)
+			.saturating_add(Weight::from_parts(0, 3675))
+			.saturating_add(T::DbWeight::get().reads(2))
+			.saturating_add(T::DbWeight::get().writes(1))
+	}
+	/// Storage: `Assets::Asset` (r:1 w:1)
+	/// Proof: `Assets::Asset` (`max_values`: None, `max_size`: Some(210), added: 2685, mode: `MaxEncodedLen`)
+	fn set_team() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `280`
+		//  Estimated: `3675`
+		// Minimum execution time: 11_569_000 picoseconds.
+		Weight::from_parts(12_049_000, 0)
+			.saturating_add(Weight::from_parts(0, 3675))
+			.saturating_add(T::DbWeight::get().reads(1))
+			.saturating_add(T::DbWeight::get().writes(1))
+	}
+	/// Storage: `Assets::Asset` (r:1 w:0)
+	/// Proof: `Assets::Asset` (`max_values`: None, `max_size`: Some(210), added: 2685, mode: `MaxEncodedLen`)
+	/// Storage: `Assets::Metadata` (r:1 w:1)
+	/// Proof: `Assets::Metadata` (`max_values`: None, `max_size`: Some(140), added: 2615, mode: `MaxEncodedLen`)
+	/// The range of component `n` is `[0, 50]`.
+	/// The range of component `s` is `[0, 50]`.
+	/// The range of component `n` is `[0, 50]`.
+	/// The range of component `s` is `[0, 50]`.
+	/// The range of component `n` is `[0, 50]`.
+	/// The range of component `s` is `[0, 50]`.
+	fn set_metadata(_n: u32, _s: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `280`
+		//  Estimated: `3675`
+		// Minimum execution time: 26_983_000 picoseconds.
+		Weight::from_parts(28_703_529, 0)
+			.saturating_add(Weight::from_parts(0, 3675))
+			.saturating_add(T::DbWeight::get().reads(2))
+			.saturating_add(T::DbWeight::get().writes(1))
+	}
+	/// Storage: `Assets::Asset` (r:1 w:0)
+	/// Proof: `Assets::Asset` (`max_values`: None, `max_size`: Some(210), added: 2685, mode: `MaxEncodedLen`)
+	/// Storage: `Assets::Metadata` (r:1 w:1)
+	/// Proof: `Assets::Metadata` (`max_values`: None, `max_size`: Some(140), added: 2615, mode: `MaxEncodedLen`)
+	fn clear_metadata() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `444`
+		//  Estimated: `3675`
+		// Minimum execution time: 27_171_000 picoseconds.
+		Weight::from_parts(28_200_000, 0)
+			.saturating_add(Weight::from_parts(0, 3675))
+			.saturating_add(T::DbWeight::get().reads(2))
+			.saturating_add(T::DbWeight::get().writes(1))
+	}
+	/// Storage: `Assets::Asset` (r:1 w:0)
+	/// Proof: `Assets::Asset` (`max_values`: None, `max_size`: Some(210), added: 2685, mode: `MaxEncodedLen`)
+	/// Storage: `Assets::Metadata` (r:1 w:1)
+	/// Proof: `Assets::Metadata` (`max_values`: None, `max_size`: Some(140), added: 2615, mode: `MaxEncodedLen`)
+	/// The range of component `n` is `[0, 50]`.
+	/// The range of component `s` is `[0, 50]`.
+	/// The range of component `n` is `[0, 50]`.
+	/// The range of component `s` is `[0, 50]`.
+	/// The range of component `n` is `[0, 50]`.
+	/// The range of component `s` is `[0, 50]`.
+	fn force_set_metadata(n: u32, s: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `119`
+		//  Estimated: `3675`
+		// Minimum execution time: 12_271_000 picoseconds.
+		Weight::from_parts(12_658_518, 0)
+			.saturating_add(Weight::from_parts(0, 3675))
+			// Standard Error: 438
+			.saturating_add(Weight::from_parts(3_068, 0).saturating_mul(n.into()))
+			// Standard Error: 438
+			.saturating_add(Weight::from_parts(4_338, 0).saturating_mul(s.into()))
+			.saturating_add(T::DbWeight::get().reads(2))
+			.saturating_add(T::DbWeight::get().writes(1))
+	}
+	/// Storage: `Assets::Asset` (r:1 w:0)
+	/// Proof: `Assets::Asset` (`max_values`: None, `max_size`: Some(210), added: 2685, mode: `MaxEncodedLen`)
+	/// Storage: `Assets::Metadata` (r:1 w:1)
+	/// Proof: `Assets::Metadata` (`max_values`: None, `max_size`: Some(140), added: 2615, mode: `MaxEncodedLen`)
+	fn force_clear_metadata() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `444`
+		//  Estimated: `3675`
+		// Minimum execution time: 26_574_000 picoseconds.
+		Weight::from_parts(27_538_000, 0)
+			.saturating_add(Weight::from_parts(0, 3675))
+			.saturating_add(T::DbWeight::get().reads(2))
+			.saturating_add(T::DbWeight::get().writes(1))
+	}
+	/// Storage: `Assets::Asset` (r:1 w:1)
+	/// Proof: `Assets::Asset` (`max_values`: None, `max_size`: Some(210), added: 2685, mode: `MaxEncodedLen`)
+	fn force_asset_status() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `280`
+		//  Estimated: `3675`
+		// Minimum execution time: 11_164_000 picoseconds.
+		Weight::from_parts(11_592_000, 0)
+			.saturating_add(Weight::from_parts(0, 3675))
+			.saturating_add(T::DbWeight::get().reads(1))
+			.saturating_add(T::DbWeight::get().writes(1))
+	}
+	/// Storage: `Assets::Asset` (r:1 w:1)
+	/// Proof: `Assets::Asset` (`max_values`: None, `max_size`: Some(210), added: 2685, mode: `MaxEncodedLen`)
+	/// Storage: `Assets::Approvals` (r:1 w:1)
+	/// Proof: `Assets::Approvals` (`max_values`: None, `max_size`: Some(148), added: 2623, mode: `MaxEncodedLen`)
+	fn approve_transfer() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `314`
+		//  Estimated: `3675`
+		// Minimum execution time: 30_723_000 picoseconds.
+		Weight::from_parts(32_100_000, 0)
+			.saturating_add(Weight::from_parts(0, 3675))
+			.saturating_add(T::DbWeight::get().reads(2))
+			.saturating_add(T::DbWeight::get().writes(2))
+	}
+	/// Storage: `Assets::Asset` (r:1 w:1)
+	/// Proof: `Assets::Asset` (`max_values`: None, `max_size`: Some(210), added: 2685, mode: `MaxEncodedLen`)
+	/// Storage: `Assets::Approvals` (r:1 w:1)
+	/// Proof: `Assets::Approvals` (`max_values`: None, `max_size`: Some(148), added: 2623, mode: `MaxEncodedLen`)
+	/// Storage: `Assets::Account` (r:2 w:2)
+	/// Proof: `Assets::Account` (`max_values`: None, `max_size`: Some(134), added: 2609, mode: `MaxEncodedLen`)
+	/// Storage: `AssetsFreezer::FrozenBalances` (r:1 w:1)
+	/// Proof: `AssetsFreezer::FrozenBalances` (`max_values`: None, `max_size`: Some(84), added: 2559, mode: `MaxEncodedLen`)
+	/// Storage: `System::Account` (r:1 w:1)
+	/// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `MaxEncodedLen`)
+	/// Storage: `AssetsFreezer::Freezes` (r:1 w:1)
+	/// Proof: `AssetsFreezer::Freezes` (`max_values`: None, `max_size`: Some(87), added: 2562, mode: `MaxEncodedLen`)
+	fn transfer_approved() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `562`
+		//  Estimated: `6208`
+		// Minimum execution time: 79_016_000 picoseconds.
+		Weight::from_parts(80_828_000, 0)
+			.saturating_add(Weight::from_parts(0, 6208))
+			.saturating_add(T::DbWeight::get().reads(7))
+			.saturating_add(T::DbWeight::get().writes(7))
+	}
+	/// Storage: `Assets::Asset` (r:1 w:1)
+	/// Proof: `Assets::Asset` (`max_values`: None, `max_size`: Some(210), added: 2685, mode: `MaxEncodedLen`)
+	/// Storage: `Assets::Approvals` (r:1 w:1)
+	/// Proof: `Assets::Approvals` (`max_values`: None, `max_size`: Some(148), added: 2623, mode: `MaxEncodedLen`)
+	fn cancel_approval() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `484`
+		//  Estimated: `3675`
+		// Minimum execution time: 33_078_000 picoseconds.
+		Weight::from_parts(34_121_000, 0)
+			.saturating_add(Weight::from_parts(0, 3675))
+			.saturating_add(T::DbWeight::get().reads(2))
+			.saturating_add(T::DbWeight::get().writes(2))
+	}
+	/// Storage: `Assets::Asset` (r:1 w:1)
+	/// Proof: `Assets::Asset` (`max_values`: None, `max_size`: Some(210), added: 2685, mode: `MaxEncodedLen`)
+	/// Storage: `Assets::Approvals` (r:1 w:1)
+	/// Proof: `Assets::Approvals` (`max_values`: None, `max_size`: Some(148), added: 2623, mode: `MaxEncodedLen`)
+	fn force_cancel_approval() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `484`
+		//  Estimated: `3675`
+		// Minimum execution time: 32_674_000 picoseconds.
+		Weight::from_parts(33_256_000, 0)
+			.saturating_add(Weight::from_parts(0, 3675))
+			.saturating_add(T::DbWeight::get().reads(2))
+			.saturating_add(T::DbWeight::get().writes(2))
+	}
+	/// Storage: `Assets::Asset` (r:1 w:1)
+	/// Proof: `Assets::Asset` (`max_values`: None, `max_size`: Some(210), added: 2685, mode: `MaxEncodedLen`)
+	fn set_min_balance() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `280`
+		//  Estimated: `3675`
+		// Minimum execution time: 12_075_000 picoseconds.
+		Weight::from_parts(12_615_000, 0)
+			.saturating_add(Weight::from_parts(0, 3675))
+			.saturating_add(T::DbWeight::get().reads(1))
+			.saturating_add(T::DbWeight::get().writes(1))
+	}
+	/// Storage: `Assets::Account` (r:1 w:1)
+	/// Proof: `Assets::Account` (`max_values`: None, `max_size`: Some(134), added: 2609, mode: `MaxEncodedLen`)
+	/// Storage: `Assets::Asset` (r:1 w:1)
+	/// Proof: `Assets::Asset` (`max_values`: None, `max_size`: Some(210), added: 2685, mode: `MaxEncodedLen`)
+	/// Storage: `System::Account` (r:1 w:1)
+	/// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `MaxEncodedLen`)
+	fn touch() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `383`
+		//  Estimated: `3675`
+		// Minimum execution time: 31_734_000 picoseconds.
+		Weight::from_parts(32_991_000, 0)
+			.saturating_add(Weight::from_parts(0, 3675))
+			.saturating_add(T::DbWeight::get().reads(3))
+			.saturating_add(T::DbWeight::get().writes(3))
+	}
+	/// Storage: `Assets::Account` (r:1 w:1)
+	/// Proof: `Assets::Account` (`max_values`: None, `max_size`: Some(134), added: 2609, mode: `MaxEncodedLen`)
+	/// Storage: `Assets::Asset` (r:1 w:1)
+	/// Proof: `Assets::Asset` (`max_values`: None, `max_size`: Some(210), added: 2685, mode: `MaxEncodedLen`)
+	fn touch_other() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `280`
+		//  Estimated: `3675`
+		// Minimum execution time: 30_207_000 picoseconds.
+		Weight::from_parts(31_152_000, 0)
+			.saturating_add(Weight::from_parts(0, 3675))
+			.saturating_add(T::DbWeight::get().reads(2))
+			.saturating_add(T::DbWeight::get().writes(2))
+	}
+	/// Storage: `Assets::Account` (r:1 w:1)
+	/// Proof: `Assets::Account` (`max_values`: None, `max_size`: Some(134), added: 2609, mode: `MaxEncodedLen`)
+	/// Storage: `Assets::Asset` (r:1 w:1)
+	/// Proof: `Assets::Asset` (`max_values`: None, `max_size`: Some(210), added: 2685, mode: `MaxEncodedLen`)
+	/// Storage: `AssetsFreezer::FrozenBalances` (r:1 w:1)
+	/// Proof: `AssetsFreezer::FrozenBalances` (`max_values`: None, `max_size`: Some(84), added: 2559, mode: `MaxEncodedLen`)
+	/// Storage: `System::Account` (r:1 w:1)
+	/// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `MaxEncodedLen`)
+	/// Storage: `AssetsFreezer::Freezes` (r:1 w:1)
+	/// Proof: `AssetsFreezer::Freezes` (`max_values`: None, `max_size`: Some(87), added: 2562, mode: `MaxEncodedLen`)
+	fn refund() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `513`
+		//  Estimated: `3675`
+		// Minimum execution time: 43_677_000 picoseconds.
+		Weight::from_parts(45_244_000, 0)
+			.saturating_add(Weight::from_parts(0, 3675))
+			.saturating_add(T::DbWeight::get().reads(5))
+			.saturating_add(T::DbWeight::get().writes(5))
+	}
+	/// Storage: `Assets::Account` (r:1 w:1)
+	/// Proof: `Assets::Account` (`max_values`: None, `max_size`: Some(134), added: 2609, mode: `MaxEncodedLen`)
+	/// Storage: `Assets::Asset` (r:1 w:1)
+	/// Proof: `Assets::Asset` (`max_values`: None, `max_size`: Some(210), added: 2685, mode: `MaxEncodedLen`)
+	/// Storage: `AssetsFreezer::FrozenBalances` (r:1 w:1)
+	/// Proof: `AssetsFreezer::FrozenBalances` (`max_values`: None, `max_size`: Some(84), added: 2559, mode: `MaxEncodedLen`)
+	/// Storage: `AssetsFreezer::Freezes` (r:1 w:1)
+	/// Proof: `AssetsFreezer::Freezes` (`max_values`: None, `max_size`: Some(87), added: 2562, mode: `MaxEncodedLen`)
+	fn refund_other() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `443`
+		//  Estimated: `3675`
+		// Minimum execution time: 41_707_000 picoseconds.
+		Weight::from_parts(43_356_000, 0)
+			.saturating_add(Weight::from_parts(0, 3675))
+			.saturating_add(T::DbWeight::get().reads(4))
+			.saturating_add(T::DbWeight::get().writes(4))
+	}
+	/// Storage: `Assets::Asset` (r:1 w:0)
+	/// Proof: `Assets::Asset` (`max_values`: None, `max_size`: Some(210), added: 2685, mode: `MaxEncodedLen`)
+	/// Storage: `Assets::Account` (r:1 w:1)
+	/// Proof: `Assets::Account` (`max_values`: None, `max_size`: Some(134), added: 2609, mode: `MaxEncodedLen`)
+	fn block() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `388`
+		//  Estimated: `3675`
+		// Minimum execution time: 16_127_000 picoseconds.
+		Weight::from_parts(16_872_000, 0)
+			.saturating_add(Weight::from_parts(0, 3675))
+			.saturating_add(T::DbWeight::get().reads(2))
+			.saturating_add(T::DbWeight::get().writes(1))
+	}
+	/// Storage: `Assets::Asset` (r:1 w:1)
+	/// Proof: `Assets::Asset` (`max_values`: None, `max_size`: Some(210), added: 2685, mode: `MaxEncodedLen`)
+	/// Storage: `Assets::Account` (r:2 w:2)
+	/// Proof: `Assets::Account` (`max_values`: None, `max_size`: Some(134), added: 2609, mode: `MaxEncodedLen`)
+	/// Storage: `AssetsFreezer::FrozenBalances` (r:1 w:1)
+	/// Proof: `AssetsFreezer::FrozenBalances` (`max_values`: None, `max_size`: Some(84), added: 2559, mode: `MaxEncodedLen`)
+	/// Storage: `AssetsFreezer::Freezes` (r:1 w:1)
+	/// Proof: `AssetsFreezer::Freezes` (`max_values`: None, `max_size`: Some(87), added: 2562, mode: `MaxEncodedLen`)
+	/// Storage: `System::Account` (r:1 w:1)
+	/// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `MaxEncodedLen`)
+	fn transfer_all() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `392`
+		//  Estimated: `6208`
+		// Minimum execution time: 69_690_000 picoseconds.
+		Weight::from_parts(72_135_000, 0)
+			.saturating_add(Weight::from_parts(0, 6208))
+			.saturating_add(T::DbWeight::get().reads(6))
+			.saturating_add(T::DbWeight::get().writes(6))
+	}
+	/// Storage: `Assets::Asset` (r:1 w:0)
+	/// Proof: `Assets::Asset` (`max_values`: None, `max_size`: Some(210), added: 2685, mode: `MaxEncodedLen`)
+	fn total_issuance() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `314`
+		//  Estimated: `3675`
+		// Minimum execution time: 5_735_000 picoseconds.
+		Weight::from_parts(5_937_000, 0)
+			.saturating_add(Weight::from_parts(0, 3675))
+			.saturating_add(T::DbWeight::get().reads(1))
+	}
+	/// Storage: `Assets::Account` (r:1 w:0)
+	/// Proof: `Assets::Account` (`max_values`: None, `max_size`: Some(134), added: 2609, mode: `MaxEncodedLen`)
+	fn balance() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `188`
+		//  Estimated: `3599`
+		// Minimum execution time: 6_622_000 picoseconds.
+		Weight::from_parts(6_995_000, 0)
+			.saturating_add(Weight::from_parts(0, 3599))
+			.saturating_add(T::DbWeight::get().reads(1))
+	}
+	/// Storage: `Assets::Approvals` (r:1 w:0)
+	/// Proof: `Assets::Approvals` (`max_values`: None, `max_size`: Some(148), added: 2623, mode: `MaxEncodedLen`)
+	fn allowance() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `283`
+		//  Estimated: `3613`
+		// Minimum execution time: 9_066_000 picoseconds.
+		Weight::from_parts(9_393_000, 0)
+			.saturating_add(Weight::from_parts(0, 3613))
+			.saturating_add(T::DbWeight::get().reads(1))
+	}
+	fn set_reserves() -> Weight {
+		Weight::from_parts(31_972_000, 3675)
+			.saturating_add(T::DbWeight::get().reads(1_u64))
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+	}
+}

pezcumulus/teyrchains/runtimes/people/people-pezkuwichain/src/weights/pallet_balances.rs

@@ -0,0 +1,177 @@
+// 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_balances`
+//!
+//! 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: `afc679a858d4`, 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/people-pezkuwichain-runtime/people_pezkuwichain_runtime.wasm
+// --pallet=pezpallet_balances
+// --header=/__w/pezkuwi-sdk/pezkuwi-sdk/pezcumulus/file_header.txt
+// --output=./pezcumulus/teyrchains/runtimes/people/people-pezkuwichain/src/weights
+// --wasm-execution=compiled
+// --steps=50
+// --repeat=20
+// --heap-pages=4096
+// --no-storage-info
+// --no-min-squares
+// --no-median-slopes
+
+#![cfg_attr(rustfmt, rustfmt_skip)]
+#![allow(unused_parens)]
+#![allow(unused_imports)]
+#![allow(missing_docs)]
+
+use pezframe_support::{traits::Get, weights::Weight};
+use core::marker::PhantomData;
+
+/// Weight functions for `pezpallet_balances`.
+pub struct WeightInfo<T>(PhantomData<T>);
+impl<T: pezframe_system::Config> pezpallet_balances::WeightInfo for WeightInfo<T> {
+	/// Storage: `System::Account` (r:1 w:1)
+	/// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `MaxEncodedLen`)
+	fn transfer_allow_death() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0`
+		//  Estimated: `3593`
+		// Minimum execution time: 49_298_000 picoseconds.
+		Weight::from_parts(50_120_000, 0)
+			.saturating_add(Weight::from_parts(0, 3593))
+			.saturating_add(T::DbWeight::get().reads(1))
+			.saturating_add(T::DbWeight::get().writes(1))
+	}
+	/// Storage: `System::Account` (r:1 w:1)
+	/// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `MaxEncodedLen`)
+	fn transfer_keep_alive() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0`
+		//  Estimated: `3593`
+		// Minimum execution time: 39_382_000 picoseconds.
+		Weight::from_parts(40_010_000, 0)
+			.saturating_add(Weight::from_parts(0, 3593))
+			.saturating_add(T::DbWeight::get().reads(1))
+			.saturating_add(T::DbWeight::get().writes(1))
+	}
+	/// Storage: `System::Account` (r:1 w:1)
+	/// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `MaxEncodedLen`)
+	fn force_set_balance_creating() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `103`
+		//  Estimated: `3593`
+		// Minimum execution time: 14_405_000 picoseconds.
+		Weight::from_parts(14_881_000, 0)
+			.saturating_add(Weight::from_parts(0, 3593))
+			.saturating_add(T::DbWeight::get().reads(1))
+			.saturating_add(T::DbWeight::get().writes(1))
+	}
+	/// Storage: `System::Account` (r:1 w:1)
+	/// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `MaxEncodedLen`)
+	fn force_set_balance_killing() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `103`
+		//  Estimated: `3593`
+		// Minimum execution time: 21_280_000 picoseconds.
+		Weight::from_parts(21_777_000, 0)
+			.saturating_add(Weight::from_parts(0, 3593))
+			.saturating_add(T::DbWeight::get().reads(1))
+			.saturating_add(T::DbWeight::get().writes(1))
+	}
+	/// Storage: `System::Account` (r:2 w:2)
+	/// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `MaxEncodedLen`)
+	fn force_transfer() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `103`
+		//  Estimated: `6196`
+		// Minimum execution time: 51_210_000 picoseconds.
+		Weight::from_parts(52_101_000, 0)
+			.saturating_add(Weight::from_parts(0, 6196))
+			.saturating_add(T::DbWeight::get().reads(2))
+			.saturating_add(T::DbWeight::get().writes(2))
+	}
+	/// Storage: `System::Account` (r:1 w:1)
+	/// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `MaxEncodedLen`)
+	fn transfer_all() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0`
+		//  Estimated: `3593`
+		// Minimum execution time: 49_150_000 picoseconds.
+		Weight::from_parts(49_845_000, 0)
+			.saturating_add(Weight::from_parts(0, 3593))
+			.saturating_add(T::DbWeight::get().reads(1))
+			.saturating_add(T::DbWeight::get().writes(1))
+	}
+	/// Storage: `System::Account` (r:1 w:1)
+	/// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `MaxEncodedLen`)
+	fn force_unreserve() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `103`
+		//  Estimated: `3593`
+		// Minimum execution time: 17_103_000 picoseconds.
+		Weight::from_parts(17_979_000, 0)
+			.saturating_add(Weight::from_parts(0, 3593))
+			.saturating_add(T::DbWeight::get().reads(1))
+			.saturating_add(T::DbWeight::get().writes(1))
+	}
+	/// Storage: `System::Account` (r:999 w:999)
+	/// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `MaxEncodedLen`)
+	/// The range of component `u` is `[1, 1000]`.
+	fn upgrade_accounts(u: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0 + u * (136 ±0)`
+		//  Estimated: `990 + u * (2603 ±0)`
+		// Minimum execution time: 16_856_000 picoseconds.
+		Weight::from_parts(17_097_000, 0)
+			.saturating_add(Weight::from_parts(0, 990))
+			// Standard Error: 11_810
+			.saturating_add(Weight::from_parts(14_844_422, 0).saturating_mul(u.into()))
+			.saturating_add(T::DbWeight::get().reads((1_u64).saturating_mul(u.into())))
+			.saturating_add(T::DbWeight::get().writes((1_u64).saturating_mul(u.into())))
+			.saturating_add(Weight::from_parts(0, 2603).saturating_mul(u.into()))
+	}
+	fn force_adjust_total_issuance() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0`
+		//  Estimated: `0`
+		// Minimum execution time: 6_069_000 picoseconds.
+		Weight::from_parts(6_556_000, 0)
+			.saturating_add(Weight::from_parts(0, 0))
+	}
+	fn burn_allow_death() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0`
+		//  Estimated: `0`
+		// Minimum execution time: 31_336_000 picoseconds.
+		Weight::from_parts(32_468_000, 0)
+			.saturating_add(Weight::from_parts(0, 0))
+	}
+	fn burn_keep_alive() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0`
+		//  Estimated: `0`
+		// Minimum execution time: 21_911_000 picoseconds.
+		Weight::from_parts(22_357_000, 0)
+			.saturating_add(Weight::from_parts(0, 0))
+	}
+}

pezcumulus/teyrchains/runtimes/people/people-pezkuwichain/src/weights/pallet_collator_selection.rs

@@ -0,0 +1,280 @@
+// 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_collator_selection`
+//!
+//! 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: `afc679a858d4`, 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/people-pezkuwichain-runtime/people_pezkuwichain_runtime.wasm
+// --pallet=pezpallet_collator_selection
+// --header=/__w/pezkuwi-sdk/pezkuwi-sdk/pezcumulus/file_header.txt
+// --output=./pezcumulus/teyrchains/runtimes/people/people-pezkuwichain/src/weights
+// --wasm-execution=compiled
+// --steps=50
+// --repeat=20
+// --heap-pages=4096
+// --no-storage-info
+// --no-min-squares
+// --no-median-slopes
+
+#![cfg_attr(rustfmt, rustfmt_skip)]
+#![allow(unused_parens)]
+#![allow(unused_imports)]
+#![allow(missing_docs)]
+
+use pezframe_support::{traits::Get, weights::Weight};
+use core::marker::PhantomData;
+
+/// Weight functions for `pezpallet_collator_selection`.
+pub struct WeightInfo<T>(PhantomData<T>);
+impl<T: pezframe_system::Config> pezpallet_collator_selection::WeightInfo for WeightInfo<T> {
+	/// Storage: `Session::NextKeys` (r:20 w:0)
+	/// Proof: `Session::NextKeys` (`max_values`: None, `max_size`: None, mode: `Measured`)
+	/// Storage: `CollatorSelection::Invulnerables` (r:0 w:1)
+	/// Proof: `CollatorSelection::Invulnerables` (`max_values`: Some(1), `max_size`: Some(641), added: 1136, mode: `MaxEncodedLen`)
+	/// The range of component `b` is `[1, 20]`.
+	fn set_invulnerables(b: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `164 + b * (79 ±0)`
+		//  Estimated: `1155 + b * (2555 ±0)`
+		// Minimum execution time: 12_804_000 picoseconds.
+		Weight::from_parts(10_801_718, 0)
+			.saturating_add(Weight::from_parts(0, 1155))
+			// Standard Error: 10_325
+			.saturating_add(Weight::from_parts(4_052_639, 0).saturating_mul(b.into()))
+			.saturating_add(T::DbWeight::get().reads((1_u64).saturating_mul(b.into())))
+			.saturating_add(T::DbWeight::get().writes(1))
+			.saturating_add(Weight::from_parts(0, 2555).saturating_mul(b.into()))
+	}
+	/// Storage: `Session::NextKeys` (r:1 w:0)
+	/// Proof: `Session::NextKeys` (`max_values`: None, `max_size`: None, mode: `Measured`)
+	/// Storage: `CollatorSelection::Invulnerables` (r:1 w:1)
+	/// Proof: `CollatorSelection::Invulnerables` (`max_values`: Some(1), `max_size`: Some(641), added: 1136, mode: `MaxEncodedLen`)
+	/// Storage: `CollatorSelection::CandidateList` (r:1 w:1)
+	/// Proof: `CollatorSelection::CandidateList` (`max_values`: Some(1), `max_size`: Some(4802), added: 5297, mode: `MaxEncodedLen`)
+	/// Storage: `System::Account` (r:1 w:1)
+	/// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `MaxEncodedLen`)
+	/// The range of component `b` is `[1, 19]`.
+	/// The range of component `c` is `[1, 99]`.
+	fn add_invulnerable(b: u32, c: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `757 + b * (32 ±0) + c * (53 ±0)`
+		//  Estimated: `6287 + b * (37 ±0) + c * (53 ±0)`
+		// Minimum execution time: 49_565_000 picoseconds.
+		Weight::from_parts(50_178_552, 0)
+			.saturating_add(Weight::from_parts(0, 6287))
+			// Standard Error: 9_536
+			.saturating_add(Weight::from_parts(135_081, 0).saturating_mul(b.into()))
+			// Standard Error: 1_807
+			.saturating_add(Weight::from_parts(133_957, 0).saturating_mul(c.into()))
+			.saturating_add(T::DbWeight::get().reads(4))
+			.saturating_add(T::DbWeight::get().writes(3))
+			.saturating_add(Weight::from_parts(0, 37).saturating_mul(b.into()))
+			.saturating_add(Weight::from_parts(0, 53).saturating_mul(c.into()))
+	}
+	/// Storage: `CollatorSelection::CandidateList` (r:1 w:0)
+	/// Proof: `CollatorSelection::CandidateList` (`max_values`: Some(1), `max_size`: Some(4802), added: 5297, mode: `MaxEncodedLen`)
+	/// Storage: `CollatorSelection::Invulnerables` (r:1 w:1)
+	/// Proof: `CollatorSelection::Invulnerables` (`max_values`: Some(1), `max_size`: Some(641), added: 1136, mode: `MaxEncodedLen`)
+	/// The range of component `b` is `[5, 20]`.
+	fn remove_invulnerable(b: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `119 + b * (32 ±0)`
+		//  Estimated: `6287`
+		// Minimum execution time: 13_065_000 picoseconds.
+		Weight::from_parts(13_170_688, 0)
+			.saturating_add(Weight::from_parts(0, 6287))
+			// Standard Error: 2_279
+			.saturating_add(Weight::from_parts(165_987, 0).saturating_mul(b.into()))
+			.saturating_add(T::DbWeight::get().reads(2))
+			.saturating_add(T::DbWeight::get().writes(1))
+	}
+	/// Storage: `CollatorSelection::DesiredCandidates` (r:0 w:1)
+	/// Proof: `CollatorSelection::DesiredCandidates` (`max_values`: Some(1), `max_size`: Some(4), added: 499, mode: `MaxEncodedLen`)
+	fn set_desired_candidates() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0`
+		//  Estimated: `0`
+		// Minimum execution time: 4_936_000 picoseconds.
+		Weight::from_parts(5_196_000, 0)
+			.saturating_add(Weight::from_parts(0, 0))
+			.saturating_add(T::DbWeight::get().writes(1))
+	}
+	/// Storage: `CollatorSelection::CandidacyBond` (r:1 w:1)
+	/// Proof: `CollatorSelection::CandidacyBond` (`max_values`: Some(1), `max_size`: Some(16), added: 511, mode: `MaxEncodedLen`)
+	/// Storage: `CollatorSelection::CandidateList` (r:1 w:1)
+	/// Proof: `CollatorSelection::CandidateList` (`max_values`: Some(1), `max_size`: Some(4802), added: 5297, mode: `MaxEncodedLen`)
+	/// Storage: `System::Account` (r:100 w:100)
+	/// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `MaxEncodedLen`)
+	/// Storage: `CollatorSelection::LastAuthoredBlock` (r:0 w:100)
+	/// Proof: `CollatorSelection::LastAuthoredBlock` (`max_values`: None, `max_size`: Some(44), added: 2519, mode: `MaxEncodedLen`)
+	/// The range of component `c` is `[0, 100]`.
+	/// The range of component `k` is `[0, 100]`.
+	fn set_candidacy_bond(c: u32, k: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0 + c * (180 ±0) + k * (112 ±0)`
+		//  Estimated: `6287 + c * (901 ±29) + k * (901 ±29)`
+		// Minimum execution time: 11_229_000 picoseconds.
+		Weight::from_parts(11_336_000, 0)
+			.saturating_add(Weight::from_parts(0, 6287))
+			// Standard Error: 175_749
+			.saturating_add(Weight::from_parts(5_988_803, 0).saturating_mul(c.into()))
+			// Standard Error: 175_749
+			.saturating_add(Weight::from_parts(5_610_271, 0).saturating_mul(k.into()))
+			.saturating_add(T::DbWeight::get().reads(2))
+			.saturating_add(T::DbWeight::get().writes(1))
+			.saturating_add(T::DbWeight::get().writes((1_u64).saturating_mul(c.into())))
+			.saturating_add(T::DbWeight::get().writes((1_u64).saturating_mul(k.into())))
+			.saturating_add(Weight::from_parts(0, 901).saturating_mul(c.into()))
+			.saturating_add(Weight::from_parts(0, 901).saturating_mul(k.into()))
+	}
+	/// Storage: `CollatorSelection::CandidacyBond` (r:1 w:0)
+	/// Proof: `CollatorSelection::CandidacyBond` (`max_values`: Some(1), `max_size`: Some(16), added: 511, mode: `MaxEncodedLen`)
+	/// Storage: `CollatorSelection::CandidateList` (r:1 w:1)
+	/// Proof: `CollatorSelection::CandidateList` (`max_values`: Some(1), `max_size`: Some(4802), added: 5297, mode: `MaxEncodedLen`)
+	/// The range of component `c` is `[4, 100]`.
+	fn update_bond(c: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `287 + c * (50 ±0)`
+		//  Estimated: `6287`
+		// Minimum execution time: 28_393_000 picoseconds.
+		Weight::from_parts(32_175_700, 0)
+			.saturating_add(Weight::from_parts(0, 6287))
+			// Standard Error: 3_970
+			.saturating_add(Weight::from_parts(141_768, 0).saturating_mul(c.into()))
+			.saturating_add(T::DbWeight::get().reads(2))
+			.saturating_add(T::DbWeight::get().writes(1))
+	}
+	/// Storage: `CollatorSelection::CandidateList` (r:1 w:1)
+	/// Proof: `CollatorSelection::CandidateList` (`max_values`: Some(1), `max_size`: Some(4802), added: 5297, mode: `MaxEncodedLen`)
+	/// Storage: `CollatorSelection::Invulnerables` (r:1 w:0)
+	/// Proof: `CollatorSelection::Invulnerables` (`max_values`: Some(1), `max_size`: Some(641), added: 1136, mode: `MaxEncodedLen`)
+	/// Storage: `Session::NextKeys` (r:1 w:0)
+	/// Proof: `Session::NextKeys` (`max_values`: None, `max_size`: None, mode: `Measured`)
+	/// Storage: `CollatorSelection::CandidacyBond` (r:1 w:0)
+	/// Proof: `CollatorSelection::CandidacyBond` (`max_values`: Some(1), `max_size`: Some(16), added: 511, mode: `MaxEncodedLen`)
+	/// Storage: `CollatorSelection::LastAuthoredBlock` (r:0 w:1)
+	/// Proof: `CollatorSelection::LastAuthoredBlock` (`max_values`: None, `max_size`: Some(44), added: 2519, mode: `MaxEncodedLen`)
+	/// The range of component `c` is `[1, 99]`.
+	fn register_as_candidate(c: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `724 + c * (52 ±0)`
+		//  Estimated: `6287 + c * (54 ±0)`
+		// Minimum execution time: 41_945_000 picoseconds.
+		Weight::from_parts(47_948_059, 0)
+			.saturating_add(Weight::from_parts(0, 6287))
+			// Standard Error: 3_134
+			.saturating_add(Weight::from_parts(167_461, 0).saturating_mul(c.into()))
+			.saturating_add(T::DbWeight::get().reads(4))
+			.saturating_add(T::DbWeight::get().writes(2))
+			.saturating_add(Weight::from_parts(0, 54).saturating_mul(c.into()))
+	}
+	/// Storage: `CollatorSelection::Invulnerables` (r:1 w:0)
+	/// Proof: `CollatorSelection::Invulnerables` (`max_values`: Some(1), `max_size`: Some(641), added: 1136, mode: `MaxEncodedLen`)
+	/// Storage: `CollatorSelection::CandidacyBond` (r:1 w:0)
+	/// Proof: `CollatorSelection::CandidacyBond` (`max_values`: Some(1), `max_size`: Some(16), added: 511, mode: `MaxEncodedLen`)
+	/// Storage: `Session::NextKeys` (r:1 w:0)
+	/// Proof: `Session::NextKeys` (`max_values`: None, `max_size`: None, mode: `Measured`)
+	/// Storage: `CollatorSelection::CandidateList` (r:1 w:1)
+	/// Proof: `CollatorSelection::CandidateList` (`max_values`: Some(1), `max_size`: Some(4802), added: 5297, mode: `MaxEncodedLen`)
+	/// Storage: `System::Account` (r:1 w:1)
+	/// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `MaxEncodedLen`)
+	/// Storage: `CollatorSelection::LastAuthoredBlock` (r:0 w:2)
+	/// Proof: `CollatorSelection::LastAuthoredBlock` (`max_values`: None, `max_size`: Some(44), added: 2519, mode: `MaxEncodedLen`)
+	/// The range of component `c` is `[4, 100]`.
+	fn take_candidate_slot(c: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `892 + c * (52 ±0)`
+		//  Estimated: `6287 + c * (55 ±0)`
+		// Minimum execution time: 60_957_000 picoseconds.
+		Weight::from_parts(66_435_263, 0)
+			.saturating_add(Weight::from_parts(0, 6287))
+			// Standard Error: 3_044
+			.saturating_add(Weight::from_parts(170_126, 0).saturating_mul(c.into()))
+			.saturating_add(T::DbWeight::get().reads(5))
+			.saturating_add(T::DbWeight::get().writes(4))
+			.saturating_add(Weight::from_parts(0, 55).saturating_mul(c.into()))
+	}
+	/// Storage: `CollatorSelection::CandidateList` (r:1 w:1)
+	/// Proof: `CollatorSelection::CandidateList` (`max_values`: Some(1), `max_size`: Some(4802), added: 5297, mode: `MaxEncodedLen`)
+	/// Storage: `CollatorSelection::Invulnerables` (r:1 w:0)
+	/// Proof: `CollatorSelection::Invulnerables` (`max_values`: Some(1), `max_size`: Some(641), added: 1136, mode: `MaxEncodedLen`)
+	/// Storage: `CollatorSelection::LastAuthoredBlock` (r:0 w:1)
+	/// Proof: `CollatorSelection::LastAuthoredBlock` (`max_values`: None, `max_size`: Some(44), added: 2519, mode: `MaxEncodedLen`)
+	/// The range of component `c` is `[4, 100]`.
+	fn leave_intent(c: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `314 + c * (48 ±0)`
+		//  Estimated: `6287`
+		// Minimum execution time: 31_777_000 picoseconds.
+		Weight::from_parts(36_837_543, 0)
+			.saturating_add(Weight::from_parts(0, 6287))
+			// Standard Error: 4_164
+			.saturating_add(Weight::from_parts(183_495, 0).saturating_mul(c.into()))
+			.saturating_add(T::DbWeight::get().reads(2))
+			.saturating_add(T::DbWeight::get().writes(2))
+	}
+	/// Storage: `System::Account` (r:2 w:2)
+	/// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `MaxEncodedLen`)
+	/// Storage: `CollatorSelection::LastAuthoredBlock` (r:0 w:1)
+	/// Proof: `CollatorSelection::LastAuthoredBlock` (`max_values`: None, `max_size`: Some(44), added: 2519, mode: `MaxEncodedLen`)
+	fn note_author() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `103`
+		//  Estimated: `6196`
+		// Minimum execution time: 42_719_000 picoseconds.
+		Weight::from_parts(43_694_000, 0)
+			.saturating_add(Weight::from_parts(0, 6196))
+			.saturating_add(T::DbWeight::get().reads(2))
+			.saturating_add(T::DbWeight::get().writes(3))
+	}
+	/// Storage: `CollatorSelection::CandidateList` (r:1 w:0)
+	/// Proof: `CollatorSelection::CandidateList` (`max_values`: Some(1), `max_size`: Some(4802), added: 5297, mode: `MaxEncodedLen`)
+	/// Storage: `CollatorSelection::LastAuthoredBlock` (r:100 w:0)
+	/// Proof: `CollatorSelection::LastAuthoredBlock` (`max_values`: None, `max_size`: Some(44), added: 2519, mode: `MaxEncodedLen`)
+	/// Storage: `CollatorSelection::Invulnerables` (r:1 w:0)
+	/// Proof: `CollatorSelection::Invulnerables` (`max_values`: Some(1), `max_size`: Some(641), added: 1136, mode: `MaxEncodedLen`)
+	/// Storage: `CollatorSelection::DesiredCandidates` (r:1 w:0)
+	/// Proof: `CollatorSelection::DesiredCandidates` (`max_values`: Some(1), `max_size`: Some(4), added: 499, mode: `MaxEncodedLen`)
+	/// Storage: `System::Account` (r:97 w:97)
+	/// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `MaxEncodedLen`)
+	/// The range of component `r` is `[1, 100]`.
+	/// The range of component `c` is `[1, 100]`.
+	fn new_session(r: u32, c: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `2180 + c * (97 ±0) + r * (112 ±0)`
+		//  Estimated: `6287 + c * (2519 ±0) + r * (2603 ±0)`
+		// Minimum execution time: 19_779_000 picoseconds.
+		Weight::from_parts(20_188_000, 0)
+			.saturating_add(Weight::from_parts(0, 6287))
+			// Standard Error: 310_110
+			.saturating_add(Weight::from_parts(14_346_415, 0).saturating_mul(c.into()))
+			.saturating_add(T::DbWeight::get().reads(4))
+			.saturating_add(T::DbWeight::get().reads((1_u64).saturating_mul(c.into())))
+			.saturating_add(T::DbWeight::get().writes((1_u64).saturating_mul(c.into())))
+			.saturating_add(Weight::from_parts(0, 2519).saturating_mul(c.into()))
+			.saturating_add(Weight::from_parts(0, 2603).saturating_mul(r.into()))
+	}
+}

pezcumulus/teyrchains/runtimes/people/people-pezkuwichain/src/weights/pallet_identity.rs

@@ -0,0 +1,579 @@
+// 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_identity`
+//!
+//! 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: `afc679a858d4`, 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/people-pezkuwichain-runtime/people_pezkuwichain_runtime.wasm
+// --pallet=pezpallet_identity
+// --header=/__w/pezkuwi-sdk/pezkuwi-sdk/pezcumulus/file_header.txt
+// --output=./pezcumulus/teyrchains/runtimes/people/people-pezkuwichain/src/weights
+// --wasm-execution=compiled
+// --steps=50
+// --repeat=20
+// --heap-pages=4096
+// --no-storage-info
+// --no-min-squares
+// --no-median-slopes
+
+#![cfg_attr(rustfmt, rustfmt_skip)]
+#![allow(unused_parens)]
+#![allow(unused_imports)]
+#![allow(missing_docs)]
+
+use pezframe_support::{traits::Get, weights::Weight};
+use core::marker::PhantomData;
+
+/// Weight functions for `pezpallet_identity`.
+pub struct WeightInfo<T>(PhantomData<T>);
+impl<T: pezframe_system::Config> pezpallet_identity::WeightInfo for WeightInfo<T> {
+	/// Storage: `Identity::Registrars` (r:1 w:1)
+	/// Proof: `Identity::Registrars` (`max_values`: Some(1), `max_size`: Some(1141), added: 1636, mode: `MaxEncodedLen`)
+	/// The range of component `r` is `[1, 19]`.
+	fn add_registrar(r: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `32 + r * (57 ±0)`
+		//  Estimated: `2626`
+		// Minimum execution time: 9_848_000 picoseconds.
+		Weight::from_parts(10_466_847, 0)
+			.saturating_add(Weight::from_parts(0, 2626))
+			// Standard Error: 1_369
+			.saturating_add(Weight::from_parts(106_104, 0).saturating_mul(r.into()))
+			.saturating_add(T::DbWeight::get().reads(1))
+			.saturating_add(T::DbWeight::get().writes(1))
+	}
+	/// Storage: `Identity::IdentityOf` (r:1 w:1)
+	/// Proof: `Identity::IdentityOf` (`max_values`: None, `max_size`: Some(804), added: 3279, mode: `MaxEncodedLen`)
+	/// The range of component `r` is `[1, 20]`.
+	fn set_identity(r: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `441 + r * (5 ±0)`
+		//  Estimated: `4269`
+		// Minimum execution time: 19_928_000 picoseconds.
+		Weight::from_parts(20_737_832, 0)
+			.saturating_add(Weight::from_parts(0, 4269))
+			// Standard Error: 1_535
+			.saturating_add(Weight::from_parts(112_440, 0).saturating_mul(r.into()))
+			.saturating_add(T::DbWeight::get().reads(1))
+			.saturating_add(T::DbWeight::get().writes(1))
+	}
+	/// Storage: `Identity::IdentityOf` (r:1 w:0)
+	/// Proof: `Identity::IdentityOf` (`max_values`: None, `max_size`: Some(804), added: 3279, mode: `MaxEncodedLen`)
+	/// Storage: `Identity::SubsOf` (r:1 w:1)
+	/// Proof: `Identity::SubsOf` (`max_values`: None, `max_size`: Some(3258), added: 5733, mode: `MaxEncodedLen`)
+	/// Storage: `Identity::SuperOf` (r:100 w:100)
+	/// Proof: `Identity::SuperOf` (`max_values`: None, `max_size`: Some(114), added: 2589, mode: `MaxEncodedLen`)
+	/// The range of component `s` is `[0, 100]`.
+	fn set_subs_new(s: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `101`
+		//  Estimated: `6723 + s * (2589 ±0)`
+		// Minimum execution time: 13_948_000 picoseconds.
+		Weight::from_parts(27_705_253, 0)
+			.saturating_add(Weight::from_parts(0, 6723))
+			// Standard Error: 6_263
+			.saturating_add(Weight::from_parts(3_717_349, 0).saturating_mul(s.into()))
+			.saturating_add(T::DbWeight::get().reads(2))
+			.saturating_add(T::DbWeight::get().reads((1_u64).saturating_mul(s.into())))
+			.saturating_add(T::DbWeight::get().writes(1))
+			.saturating_add(T::DbWeight::get().writes((1_u64).saturating_mul(s.into())))
+			.saturating_add(Weight::from_parts(0, 2589).saturating_mul(s.into()))
+	}
+	/// Storage: `Identity::IdentityOf` (r:1 w:0)
+	/// Proof: `Identity::IdentityOf` (`max_values`: None, `max_size`: Some(804), added: 3279, mode: `MaxEncodedLen`)
+	/// Storage: `Identity::SubsOf` (r:1 w:1)
+	/// Proof: `Identity::SubsOf` (`max_values`: None, `max_size`: Some(3258), added: 5733, mode: `MaxEncodedLen`)
+	/// Storage: `Identity::SuperOf` (r:0 w:100)
+	/// Proof: `Identity::SuperOf` (`max_values`: None, `max_size`: Some(114), added: 2589, mode: `MaxEncodedLen`)
+	/// The range of component `p` is `[0, 100]`.
+	fn set_subs_old(p: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `194 + p * (32 ±0)`
+		//  Estimated: `6723`
+		// Minimum execution time: 13_719_000 picoseconds.
+		Weight::from_parts(27_841_625, 0)
+			.saturating_add(Weight::from_parts(0, 6723))
+			// Standard Error: 4_083
+			.saturating_add(Weight::from_parts(1_432_686, 0).saturating_mul(p.into()))
+			.saturating_add(T::DbWeight::get().reads(2))
+			.saturating_add(T::DbWeight::get().writes(1))
+			.saturating_add(T::DbWeight::get().writes((1_u64).saturating_mul(p.into())))
+	}
+	/// Storage: `Identity::SubsOf` (r:1 w:1)
+	/// Proof: `Identity::SubsOf` (`max_values`: None, `max_size`: Some(3258), added: 5733, mode: `MaxEncodedLen`)
+	/// Storage: `Identity::IdentityOf` (r:1 w:1)
+	/// Proof: `Identity::IdentityOf` (`max_values`: None, `max_size`: Some(804), added: 3279, mode: `MaxEncodedLen`)
+	/// Storage: `Identity::SuperOf` (r:0 w:100)
+	/// Proof: `Identity::SuperOf` (`max_values`: None, `max_size`: Some(114), added: 2589, mode: `MaxEncodedLen`)
+	/// The range of component `r` is `[1, 20]`.
+	/// The range of component `s` is `[0, 100]`.
+	fn clear_identity(r: u32, s: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `533 + r * (5 ±0) + s * (32 ±0)`
+		//  Estimated: `6723`
+		// Minimum execution time: 31_443_000 picoseconds.
+		Weight::from_parts(31_973_880, 0)
+			.saturating_add(Weight::from_parts(0, 6723))
+			// Standard Error: 26_019
+			.saturating_add(Weight::from_parts(190_904, 0).saturating_mul(r.into()))
+			// Standard Error: 5_077
+			.saturating_add(Weight::from_parts(1_416_448, 0).saturating_mul(s.into()))
+			.saturating_add(T::DbWeight::get().reads(2))
+			.saturating_add(T::DbWeight::get().writes(2))
+			.saturating_add(T::DbWeight::get().writes((1_u64).saturating_mul(s.into())))
+	}
+	/// Storage: `Identity::Registrars` (r:1 w:0)
+	/// Proof: `Identity::Registrars` (`max_values`: Some(1), `max_size`: Some(1141), added: 1636, mode: `MaxEncodedLen`)
+	/// Storage: `Identity::IdentityOf` (r:1 w:1)
+	/// Proof: `Identity::IdentityOf` (`max_values`: None, `max_size`: Some(804), added: 3279, mode: `MaxEncodedLen`)
+	/// The range of component `r` is `[1, 20]`.
+	fn request_judgement(r: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `431 + r * (57 ±0)`
+		//  Estimated: `4269`
+		// Minimum execution time: 31_044_000 picoseconds.
+		Weight::from_parts(32_326_692, 0)
+			.saturating_add(Weight::from_parts(0, 4269))
+			// Standard Error: 2_758
+			.saturating_add(Weight::from_parts(143_778, 0).saturating_mul(r.into()))
+			.saturating_add(T::DbWeight::get().reads(2))
+			.saturating_add(T::DbWeight::get().writes(1))
+	}
+	/// Storage: `Identity::IdentityOf` (r:1 w:1)
+	/// Proof: `Identity::IdentityOf` (`max_values`: None, `max_size`: Some(804), added: 3279, mode: `MaxEncodedLen`)
+	/// The range of component `r` is `[1, 20]`.
+	fn cancel_request(r: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `462`
+		//  Estimated: `4269`
+		// Minimum execution time: 29_052_000 picoseconds.
+		Weight::from_parts(29_936_298, 0)
+			.saturating_add(Weight::from_parts(0, 4269))
+			// Standard Error: 2_163
+			.saturating_add(Weight::from_parts(111_011, 0).saturating_mul(r.into()))
+			.saturating_add(T::DbWeight::get().reads(1))
+			.saturating_add(T::DbWeight::get().writes(1))
+	}
+	/// Storage: `Identity::Registrars` (r:1 w:1)
+	/// Proof: `Identity::Registrars` (`max_values`: Some(1), `max_size`: Some(1141), added: 1636, mode: `MaxEncodedLen`)
+	/// The range of component `r` is `[1, 19]`.
+	fn set_fee(r: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `89 + r * (57 ±0)`
+		//  Estimated: `2626`
+		// Minimum execution time: 6_877_000 picoseconds.
+		Weight::from_parts(7_427_649, 0)
+			.saturating_add(Weight::from_parts(0, 2626))
+			// Standard Error: 1_398
+			.saturating_add(Weight::from_parts(80_293, 0).saturating_mul(r.into()))
+			.saturating_add(T::DbWeight::get().reads(1))
+			.saturating_add(T::DbWeight::get().writes(1))
+	}
+	/// Storage: `Identity::Registrars` (r:1 w:1)
+	/// Proof: `Identity::Registrars` (`max_values`: Some(1), `max_size`: Some(1141), added: 1636, mode: `MaxEncodedLen`)
+	/// The range of component `r` is `[1, 19]`.
+	fn set_account_id(r: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `89 + r * (57 ±0)`
+		//  Estimated: `2626`
+		// Minimum execution time: 7_042_000 picoseconds.
+		Weight::from_parts(7_602_430, 0)
+			.saturating_add(Weight::from_parts(0, 2626))
+			// Standard Error: 1_162
+			.saturating_add(Weight::from_parts(71_047, 0).saturating_mul(r.into()))
+			.saturating_add(T::DbWeight::get().reads(1))
+			.saturating_add(T::DbWeight::get().writes(1))
+	}
+	/// Storage: `Identity::Registrars` (r:1 w:1)
+	/// Proof: `Identity::Registrars` (`max_values`: Some(1), `max_size`: Some(1141), added: 1636, mode: `MaxEncodedLen`)
+	/// The range of component `r` is `[1, 19]`.
+	fn set_fields(r: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `89 + r * (57 ±0)`
+		//  Estimated: `2626`
+		// Minimum execution time: 6_854_000 picoseconds.
+		Weight::from_parts(7_329_901, 0)
+			.saturating_add(Weight::from_parts(0, 2626))
+			// Standard Error: 1_018
+			.saturating_add(Weight::from_parts(75_560, 0).saturating_mul(r.into()))
+			.saturating_add(T::DbWeight::get().reads(1))
+			.saturating_add(T::DbWeight::get().writes(1))
+	}
+	/// Storage: `Identity::Registrars` (r:1 w:0)
+	/// Proof: `Identity::Registrars` (`max_values`: Some(1), `max_size`: Some(1141), added: 1636, mode: `MaxEncodedLen`)
+	/// Storage: `Identity::IdentityOf` (r:1 w:1)
+	/// Proof: `Identity::IdentityOf` (`max_values`: None, `max_size`: Some(804), added: 3279, mode: `MaxEncodedLen`)
+	/// The range of component `r` is `[1, 19]`.
+	fn provide_judgement(r: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `509 + r * (57 ±0)`
+		//  Estimated: `4269`
+		// Minimum execution time: 21_996_000 picoseconds.
+		Weight::from_parts(22_871_139, 0)
+			.saturating_add(Weight::from_parts(0, 4269))
+			// Standard Error: 1_805
+			.saturating_add(Weight::from_parts(100_041, 0).saturating_mul(r.into()))
+			.saturating_add(T::DbWeight::get().reads(2))
+			.saturating_add(T::DbWeight::get().writes(1))
+	}
+	/// Storage: `Identity::SubsOf` (r:1 w:1)
+	/// Proof: `Identity::SubsOf` (`max_values`: None, `max_size`: Some(3258), added: 5733, mode: `MaxEncodedLen`)
+	/// Storage: `Identity::IdentityOf` (r:1 w:1)
+	/// Proof: `Identity::IdentityOf` (`max_values`: None, `max_size`: Some(804), added: 3279, mode: `MaxEncodedLen`)
+	/// Storage: `System::Account` (r:2 w:2)
+	/// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `MaxEncodedLen`)
+	/// Storage: `TeyrchainInfo::TeyrchainId` (r:1 w:0)
+	/// Proof: `TeyrchainInfo::TeyrchainId` (`max_values`: Some(1), `max_size`: Some(4), added: 499, mode: `MaxEncodedLen`)
+	/// Storage: `PezkuwiXcm::ShouldRecordXcm` (r:1 w:0)
+	/// Proof: `PezkuwiXcm::ShouldRecordXcm` (`max_values`: Some(1), `max_size`: None, mode: `Measured`)
+	/// Storage: `Identity::SuperOf` (r:0 w:100)
+	/// Proof: `Identity::SuperOf` (`max_values`: None, `max_size`: Some(114), added: 2589, mode: `MaxEncodedLen`)
+	/// The range of component `r` is `[1, 20]`.
+	/// The range of component `s` is `[0, 100]`.
+	fn kill_identity(r: u32, s: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `742 + r * (5 ±0) + s * (32 ±0)`
+		//  Estimated: `6723 + r * (6 ±0) + s * (32 ±0)`
+		// Minimum execution time: 84_637_000 picoseconds.
+		Weight::from_parts(88_522_543, 0)
+			.saturating_add(Weight::from_parts(0, 6723))
+			// Standard Error: 19_867
+			.saturating_add(Weight::from_parts(461_065, 0).saturating_mul(r.into()))
+			// Standard Error: 3_876
+			.saturating_add(Weight::from_parts(1_506_725, 0).saturating_mul(s.into()))
+			.saturating_add(T::DbWeight::get().reads(6))
+			.saturating_add(T::DbWeight::get().writes(4))
+			.saturating_add(T::DbWeight::get().writes((1_u64).saturating_mul(s.into())))
+			.saturating_add(Weight::from_parts(0, 6).saturating_mul(r.into()))
+			.saturating_add(Weight::from_parts(0, 32).saturating_mul(s.into()))
+	}
+	/// Storage: `Identity::IdentityOf` (r:1 w:0)
+	/// Proof: `Identity::IdentityOf` (`max_values`: None, `max_size`: Some(804), added: 3279, mode: `MaxEncodedLen`)
+	/// Storage: `Identity::SuperOf` (r:1 w:1)
+	/// Proof: `Identity::SuperOf` (`max_values`: None, `max_size`: Some(114), added: 2589, mode: `MaxEncodedLen`)
+	/// Storage: `Identity::SubsOf` (r:1 w:1)
+	/// Proof: `Identity::SubsOf` (`max_values`: None, `max_size`: Some(3258), added: 5733, mode: `MaxEncodedLen`)
+	/// The range of component `s` is `[0, 99]`.
+	fn add_sub(s: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `475 + s * (36 ±0)`
+		//  Estimated: `6723`
+		// Minimum execution time: 29_500_000 picoseconds.
+		Weight::from_parts(35_101_317, 0)
+			.saturating_add(Weight::from_parts(0, 6723))
+			// Standard Error: 1_634
+			.saturating_add(Weight::from_parts(115_225, 0).saturating_mul(s.into()))
+			.saturating_add(T::DbWeight::get().reads(3))
+			.saturating_add(T::DbWeight::get().writes(2))
+	}
+	/// Storage: `Identity::IdentityOf` (r:1 w:0)
+	/// Proof: `Identity::IdentityOf` (`max_values`: None, `max_size`: Some(804), added: 3279, mode: `MaxEncodedLen`)
+	/// Storage: `Identity::SuperOf` (r:1 w:1)
+	/// Proof: `Identity::SuperOf` (`max_values`: None, `max_size`: Some(114), added: 2589, mode: `MaxEncodedLen`)
+	/// The range of component `s` is `[1, 100]`.
+	fn rename_sub(s: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `591 + s * (3 ±0)`
+		//  Estimated: `4269`
+		// Minimum execution time: 18_210_000 picoseconds.
+		Weight::from_parts(20_927_042, 0)
+			.saturating_add(Weight::from_parts(0, 4269))
+			// Standard Error: 768
+			.saturating_add(Weight::from_parts(61_741, 0).saturating_mul(s.into()))
+			.saturating_add(T::DbWeight::get().reads(2))
+			.saturating_add(T::DbWeight::get().writes(1))
+	}
+	/// Storage: `Identity::IdentityOf` (r:1 w:0)
+	/// Proof: `Identity::IdentityOf` (`max_values`: None, `max_size`: Some(804), added: 3279, mode: `MaxEncodedLen`)
+	/// Storage: `Identity::SuperOf` (r:1 w:1)
+	/// Proof: `Identity::SuperOf` (`max_values`: None, `max_size`: Some(114), added: 2589, mode: `MaxEncodedLen`)
+	/// Storage: `Identity::SubsOf` (r:1 w:1)
+	/// Proof: `Identity::SubsOf` (`max_values`: None, `max_size`: Some(3258), added: 5733, mode: `MaxEncodedLen`)
+	/// The range of component `s` is `[1, 100]`.
+	fn remove_sub(s: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `638 + s * (35 ±0)`
+		//  Estimated: `6723`
+		// Minimum execution time: 33_777_000 picoseconds.
+		Weight::from_parts(41_132_711, 0)
+			.saturating_add(Weight::from_parts(0, 6723))
+			// Standard Error: 1_840
+			.saturating_add(Weight::from_parts(108_430, 0).saturating_mul(s.into()))
+			.saturating_add(T::DbWeight::get().reads(3))
+			.saturating_add(T::DbWeight::get().writes(2))
+	}
+	/// Storage: `Identity::SuperOf` (r:1 w:1)
+	/// Proof: `Identity::SuperOf` (`max_values`: None, `max_size`: Some(114), added: 2589, mode: `MaxEncodedLen`)
+	/// Storage: `Identity::SubsOf` (r:1 w:1)
+	/// Proof: `Identity::SubsOf` (`max_values`: None, `max_size`: Some(3258), added: 5733, mode: `MaxEncodedLen`)
+	/// Storage: `System::Account` (r:1 w:0)
+	/// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `MaxEncodedLen`)
+	/// The range of component `s` is `[0, 99]`.
+	fn quit_sub(s: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `667 + s * (37 ±0)`
+		//  Estimated: `6723`
+		// Minimum execution time: 24_421_000 picoseconds.
+		Weight::from_parts(28_181_575, 0)
+			.saturating_add(Weight::from_parts(0, 6723))
+			// Standard Error: 2_548
+			.saturating_add(Weight::from_parts(148_324, 0).saturating_mul(s.into()))
+			.saturating_add(T::DbWeight::get().reads(3))
+			.saturating_add(T::DbWeight::get().writes(2))
+	}
+	/// Storage: `Identity::AuthorityOf` (r:0 w:1)
+	/// Proof: `Identity::AuthorityOf` (`max_values`: None, `max_size`: Some(52), added: 2527, mode: `MaxEncodedLen`)
+	fn add_username_authority() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0`
+		//  Estimated: `0`
+		// Minimum execution time: 7_053_000 picoseconds.
+		Weight::from_parts(7_337_000, 0)
+			.saturating_add(Weight::from_parts(0, 0))
+			.saturating_add(T::DbWeight::get().writes(1))
+	}
+	/// Storage: `Identity::AuthorityOf` (r:1 w:1)
+	/// Proof: `Identity::AuthorityOf` (`max_values`: None, `max_size`: Some(52), added: 2527, mode: `MaxEncodedLen`)
+	fn remove_username_authority() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `79`
+		//  Estimated: `3517`
+		// Minimum execution time: 10_714_000 picoseconds.
+		Weight::from_parts(11_383_000, 0)
+			.saturating_add(Weight::from_parts(0, 3517))
+			.saturating_add(T::DbWeight::get().reads(1))
+			.saturating_add(T::DbWeight::get().writes(1))
+	}
+	/// Storage: `Identity::AuthorityOf` (r:1 w:1)
+	/// Proof: `Identity::AuthorityOf` (`max_values`: None, `max_size`: Some(52), added: 2527, mode: `MaxEncodedLen`)
+	/// Storage: `Identity::UsernameInfoOf` (r:1 w:1)
+	/// Proof: `Identity::UsernameInfoOf` (`max_values`: None, `max_size`: Some(98), added: 2573, mode: `MaxEncodedLen`)
+	/// Storage: `Identity::PendingUsernames` (r:1 w:0)
+	/// Proof: `Identity::PendingUsernames` (`max_values`: None, `max_size`: Some(102), added: 2577, mode: `MaxEncodedLen`)
+	/// Storage: `Identity::UsernameOf` (r:1 w:1)
+	/// Proof: `Identity::UsernameOf` (`max_values`: None, `max_size`: Some(73), added: 2548, mode: `MaxEncodedLen`)
+	/// Storage: `System::Account` (r:1 w:1)
+	/// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `MaxEncodedLen`)
+	/// The range of component `p` is `[0, 1]`.
+	fn set_username_for(_p: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `182`
+		//  Estimated: `3593`
+		// Minimum execution time: 68_588_000 picoseconds.
+		Weight::from_parts(88_797_132, 0)
+			.saturating_add(Weight::from_parts(0, 3593))
+			.saturating_add(T::DbWeight::get().reads(5))
+			.saturating_add(T::DbWeight::get().writes(4))
+	}
+	/// Storage: `Identity::PendingUsernames` (r:1 w:1)
+	/// Proof: `Identity::PendingUsernames` (`max_values`: None, `max_size`: Some(102), added: 2577, mode: `MaxEncodedLen`)
+	/// Storage: `Identity::UsernameOf` (r:1 w:1)
+	/// Proof: `Identity::UsernameOf` (`max_values`: None, `max_size`: Some(73), added: 2548, mode: `MaxEncodedLen`)
+	/// Storage: `Identity::UsernameInfoOf` (r:0 w:1)
+	/// Proof: `Identity::UsernameInfoOf` (`max_values`: None, `max_size`: Some(98), added: 2573, mode: `MaxEncodedLen`)
+	fn accept_username() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `116`
+		//  Estimated: `3567`
+		// Minimum execution time: 21_542_000 picoseconds.
+		Weight::from_parts(22_436_000, 0)
+			.saturating_add(Weight::from_parts(0, 3567))
+			.saturating_add(T::DbWeight::get().reads(2))
+			.saturating_add(T::DbWeight::get().writes(3))
+	}
+	/// Storage: `Identity::PendingUsernames` (r:1 w:1)
+	/// Proof: `Identity::PendingUsernames` (`max_values`: None, `max_size`: Some(102), added: 2577, mode: `MaxEncodedLen`)
+	/// Storage: `Identity::AuthorityOf` (r:1 w:0)
+	/// Proof: `Identity::AuthorityOf` (`max_values`: None, `max_size`: Some(52), added: 2527, mode: `MaxEncodedLen`)
+	/// Storage: `System::Account` (r:1 w:1)
+	/// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `MaxEncodedLen`)
+	/// The range of component `p` is `[0, 1]`.
+	fn remove_expired_approval(_p: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `310`
+		//  Estimated: `3593`
+		// Minimum execution time: 15_593_000 picoseconds.
+		Weight::from_parts(38_944_828, 0)
+			.saturating_add(Weight::from_parts(0, 3593))
+			.saturating_add(T::DbWeight::get().reads(3))
+			.saturating_add(T::DbWeight::get().writes(2))
+	}
+	/// Storage: `Identity::UsernameInfoOf` (r:1 w:0)
+	/// Proof: `Identity::UsernameInfoOf` (`max_values`: None, `max_size`: Some(98), added: 2573, mode: `MaxEncodedLen`)
+	/// Storage: `Identity::UsernameOf` (r:0 w:1)
+	/// Proof: `Identity::UsernameOf` (`max_values`: None, `max_size`: Some(73), added: 2548, mode: `MaxEncodedLen`)
+	fn set_primary_username() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `172`
+		//  Estimated: `3563`
+		// Minimum execution time: 13_891_000 picoseconds.
+		Weight::from_parts(14_833_000, 0)
+			.saturating_add(Weight::from_parts(0, 3563))
+			.saturating_add(T::DbWeight::get().reads(1))
+			.saturating_add(T::DbWeight::get().writes(1))
+	}
+	/// Storage: `Identity::UsernameInfoOf` (r:1 w:0)
+	/// Proof: `Identity::UsernameInfoOf` (`max_values`: None, `max_size`: Some(98), added: 2573, mode: `MaxEncodedLen`)
+	/// Storage: `Identity::AuthorityOf` (r:1 w:0)
+	/// Proof: `Identity::AuthorityOf` (`max_values`: None, `max_size`: Some(52), added: 2527, mode: `MaxEncodedLen`)
+	/// Storage: `Identity::UnbindingUsernames` (r:1 w:1)
+	/// Proof: `Identity::UnbindingUsernames` (`max_values`: None, `max_size`: Some(53), added: 2528, mode: `MaxEncodedLen`)
+	fn unbind_username() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `236`
+		//  Estimated: `3563`
+		// Minimum execution time: 18_974_000 picoseconds.
+		Weight::from_parts(19_243_000, 0)
+			.saturating_add(Weight::from_parts(0, 3563))
+			.saturating_add(T::DbWeight::get().reads(3))
+			.saturating_add(T::DbWeight::get().writes(1))
+	}
+	/// Storage: `Identity::UnbindingUsernames` (r:1 w:1)
+	/// Proof: `Identity::UnbindingUsernames` (`max_values`: None, `max_size`: Some(53), added: 2528, mode: `MaxEncodedLen`)
+	/// Storage: `Identity::UsernameInfoOf` (r:1 w:1)
+	/// Proof: `Identity::UsernameInfoOf` (`max_values`: None, `max_size`: Some(98), added: 2573, mode: `MaxEncodedLen`)
+	/// Storage: `Identity::UsernameOf` (r:1 w:1)
+	/// Proof: `Identity::UsernameOf` (`max_values`: None, `max_size`: Some(73), added: 2548, mode: `MaxEncodedLen`)
+	/// Storage: `Identity::AuthorityOf` (r:1 w:0)
+	/// Proof: `Identity::AuthorityOf` (`max_values`: None, `max_size`: Some(52), added: 2527, mode: `MaxEncodedLen`)
+	fn remove_username() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `297`
+		//  Estimated: `3563`
+		// Minimum execution time: 23_448_000 picoseconds.
+		Weight::from_parts(24_410_000, 0)
+			.saturating_add(Weight::from_parts(0, 3563))
+			.saturating_add(T::DbWeight::get().reads(4))
+			.saturating_add(T::DbWeight::get().writes(3))
+	}
+	/// Storage: `Identity::UsernameInfoOf` (r:1 w:1)
+	/// Proof: `Identity::UsernameInfoOf` (`max_values`: None, `max_size`: Some(98), added: 2573, mode: `MaxEncodedLen`)
+	/// Storage: `Identity::UsernameOf` (r:1 w:1)
+	/// Proof: `Identity::UsernameOf` (`max_values`: None, `max_size`: Some(73), added: 2548, mode: `MaxEncodedLen`)
+	/// Storage: `Identity::UnbindingUsernames` (r:1 w:1)
+	/// Proof: `Identity::UnbindingUsernames` (`max_values`: None, `max_size`: Some(53), added: 2528, mode: `MaxEncodedLen`)
+	/// Storage: `Identity::AuthorityOf` (r:1 w:0)
+	/// Proof: `Identity::AuthorityOf` (`max_values`: None, `max_size`: Some(52), added: 2527, mode: `MaxEncodedLen`)
+	/// Storage: `System::Account` (r:2 w:1)
+	/// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `MaxEncodedLen`)
+	/// Storage: `TeyrchainInfo::TeyrchainId` (r:1 w:0)
+	/// Proof: `TeyrchainInfo::TeyrchainId` (`max_values`: Some(1), `max_size`: Some(4), added: 499, mode: `MaxEncodedLen`)
+	/// Storage: `PezkuwiXcm::ShouldRecordXcm` (r:1 w:0)
+	/// Proof: `PezkuwiXcm::ShouldRecordXcm` (`max_values`: Some(1), `max_size`: None, mode: `Measured`)
+	/// The range of component `p` is `[0, 1]`.
+	fn kill_username(_p: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `540`
+		//  Estimated: `6196`
+		// Minimum execution time: 21_407_000 picoseconds.
+		Weight::from_parts(82_016_546, 0)
+			.saturating_add(Weight::from_parts(0, 6196))
+			.saturating_add(T::DbWeight::get().reads(8))
+			.saturating_add(T::DbWeight::get().writes(4))
+	}
+	/// Storage: UNKNOWN KEY `0x2aeddc77fe58c98d50bd37f1b90840f99622d1423cdd16f5c33e2b531c34a53d` (r:2 w:0)
+	/// Proof: UNKNOWN KEY `0x2aeddc77fe58c98d50bd37f1b90840f99622d1423cdd16f5c33e2b531c34a53d` (r:2 w:0)
+	/// Storage: `Identity::AuthorityOf` (r:0 w:1)
+	/// Proof: `Identity::AuthorityOf` (`max_values`: None, `max_size`: Some(52), added: 2527, mode: `MaxEncodedLen`)
+	fn migration_v2_authority_step() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `147`
+		//  Estimated: `6087`
+		// Minimum execution time: 8_850_000 picoseconds.
+		Weight::from_parts(9_249_000, 0)
+			.saturating_add(Weight::from_parts(0, 6087))
+			.saturating_add(T::DbWeight::get().reads(2))
+			.saturating_add(T::DbWeight::get().writes(1))
+	}
+	/// Storage: UNKNOWN KEY `0x2aeddc77fe58c98d50bd37f1b90840f97c182fead9255863460affdd63116be3` (r:2 w:0)
+	/// Proof: UNKNOWN KEY `0x2aeddc77fe58c98d50bd37f1b90840f97c182fead9255863460affdd63116be3` (r:2 w:0)
+	/// Storage: `Identity::UsernameInfoOf` (r:0 w:1)
+	/// Proof: `Identity::UsernameInfoOf` (`max_values`: None, `max_size`: Some(98), added: 2573, mode: `MaxEncodedLen`)
+	fn migration_v2_username_step() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `159`
+		//  Estimated: `6099`
+		// Minimum execution time: 8_810_000 picoseconds.
+		Weight::from_parts(9_163_000, 0)
+			.saturating_add(Weight::from_parts(0, 6099))
+			.saturating_add(T::DbWeight::get().reads(2))
+			.saturating_add(T::DbWeight::get().writes(1))
+	}
+	/// Storage: `Identity::IdentityOf` (r:2 w:1)
+	/// Proof: `Identity::IdentityOf` (`max_values`: None, `max_size`: Some(804), added: 3279, mode: `MaxEncodedLen`)
+	/// Storage: `Identity::UsernameOf` (r:0 w:1)
+	/// Proof: `Identity::UsernameOf` (`max_values`: None, `max_size`: Some(73), added: 2548, mode: `MaxEncodedLen`)
+	fn migration_v2_identity_step() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `526`
+		//  Estimated: `7548`
+		// Minimum execution time: 13_549_000 picoseconds.
+		Weight::from_parts(14_194_000, 0)
+			.saturating_add(Weight::from_parts(0, 7548))
+			.saturating_add(T::DbWeight::get().reads(2))
+			.saturating_add(T::DbWeight::get().writes(2))
+	}
+	/// Storage: `Identity::PendingUsernames` (r:2 w:1)
+	/// Proof: `Identity::PendingUsernames` (`max_values`: None, `max_size`: Some(102), added: 2577, mode: `MaxEncodedLen`)
+	fn migration_v2_pending_username_step() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `201`
+		//  Estimated: `6144`
+		// Minimum execution time: 8_112_000 picoseconds.
+		Weight::from_parts(8_441_000, 0)
+			.saturating_add(Weight::from_parts(0, 6144))
+			.saturating_add(T::DbWeight::get().reads(2))
+			.saturating_add(T::DbWeight::get().writes(1))
+	}
+	/// Storage: `Identity::AuthorityOf` (r:2 w:0)
+	/// Proof: `Identity::AuthorityOf` (`max_values`: None, `max_size`: Some(52), added: 2527, mode: `MaxEncodedLen`)
+	/// Storage: UNKNOWN KEY `0x2aeddc77fe58c98d50bd37f1b90840f99622d1423cdd16f5c33e2b531c34a53d` (r:1 w:1)
+	/// Proof: UNKNOWN KEY `0x2aeddc77fe58c98d50bd37f1b90840f99622d1423cdd16f5c33e2b531c34a53d` (r:1 w:1)
+	fn migration_v2_cleanup_authority_step() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `288`
+		//  Estimated: `6044`
+		// Minimum execution time: 11_749_000 picoseconds.
+		Weight::from_parts(12_322_000, 0)
+			.saturating_add(Weight::from_parts(0, 6044))
+			.saturating_add(T::DbWeight::get().reads(3))
+			.saturating_add(T::DbWeight::get().writes(1))
+	}
+	/// Storage: `Identity::UsernameInfoOf` (r:2 w:0)
+	/// Proof: `Identity::UsernameInfoOf` (`max_values`: None, `max_size`: Some(98), added: 2573, mode: `MaxEncodedLen`)
+	/// Storage: UNKNOWN KEY `0x2aeddc77fe58c98d50bd37f1b90840f97c182fead9255863460affdd63116be3` (r:1 w:1)
+	/// Proof: UNKNOWN KEY `0x2aeddc77fe58c98d50bd37f1b90840f97c182fead9255863460affdd63116be3` (r:1 w:1)
+	fn migration_v2_cleanup_username_step() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `290`
+		//  Estimated: `6136`
+		// Minimum execution time: 10_486_000 picoseconds.
+		Weight::from_parts(11_408_000, 0)
+			.saturating_add(Weight::from_parts(0, 6136))
+			.saturating_add(T::DbWeight::get().reads(3))
+			.saturating_add(T::DbWeight::get().writes(1))
+	}
+}

pezcumulus/teyrchains/runtimes/people/people-pezkuwichain/src/weights/pallet_message_queue.rs

@@ -0,0 +1,200 @@
+// 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_message_queue`
+//!
+//! 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: `afc679a858d4`, 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/people-pezkuwichain-runtime/people_pezkuwichain_runtime.wasm
+// --pallet=pezpallet_message_queue
+// --header=/__w/pezkuwi-sdk/pezkuwi-sdk/pezcumulus/file_header.txt
+// --output=./pezcumulus/teyrchains/runtimes/people/people-pezkuwichain/src/weights
+// --wasm-execution=compiled
+// --steps=50
+// --repeat=20
+// --heap-pages=4096
+// --no-storage-info
+// --no-min-squares
+// --no-median-slopes
+
+#![cfg_attr(rustfmt, rustfmt_skip)]
+#![allow(unused_parens)]
+#![allow(unused_imports)]
+#![allow(missing_docs)]
+
+use pezframe_support::{traits::Get, weights::Weight};
+use core::marker::PhantomData;
+
+/// Weight functions for `pezpallet_message_queue`.
+pub struct WeightInfo<T>(PhantomData<T>);
+impl<T: pezframe_system::Config> pezpallet_message_queue::WeightInfo for WeightInfo<T> {
+	/// Storage: `MessageQueue::ServiceHead` (r:1 w:0)
+	/// Proof: `MessageQueue::ServiceHead` (`max_values`: Some(1), `max_size`: Some(5), added: 500, mode: `MaxEncodedLen`)
+	/// Storage: `MessageQueue::BookStateFor` (r:2 w:2)
+	/// Proof: `MessageQueue::BookStateFor` (`max_values`: None, `max_size`: Some(52), added: 2527, mode: `MaxEncodedLen`)
+	fn ready_ring_knit() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `223`
+		//  Estimated: `6044`
+		// Minimum execution time: 13_244_000 picoseconds.
+		Weight::from_parts(14_004_000, 0)
+			.saturating_add(Weight::from_parts(0, 6044))
+			.saturating_add(T::DbWeight::get().reads(3))
+			.saturating_add(T::DbWeight::get().writes(2))
+	}
+	/// Storage: `MessageQueue::BookStateFor` (r:2 w:2)
+	/// Proof: `MessageQueue::BookStateFor` (`max_values`: None, `max_size`: Some(52), added: 2527, mode: `MaxEncodedLen`)
+	/// Storage: `MessageQueue::ServiceHead` (r:1 w:1)
+	/// Proof: `MessageQueue::ServiceHead` (`max_values`: Some(1), `max_size`: Some(5), added: 500, mode: `MaxEncodedLen`)
+	fn ready_ring_unknit() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `218`
+		//  Estimated: `6044`
+		// Minimum execution time: 12_387_000 picoseconds.
+		Weight::from_parts(12_858_000, 0)
+			.saturating_add(Weight::from_parts(0, 6044))
+			.saturating_add(T::DbWeight::get().reads(3))
+			.saturating_add(T::DbWeight::get().writes(3))
+	}
+	/// Storage: `MessageQueue::BookStateFor` (r:1 w:1)
+	/// Proof: `MessageQueue::BookStateFor` (`max_values`: None, `max_size`: Some(52), added: 2527, mode: `MaxEncodedLen`)
+	fn service_queue_base() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `6`
+		//  Estimated: `3517`
+		// Minimum execution time: 4_116_000 picoseconds.
+		Weight::from_parts(4_387_000, 0)
+			.saturating_add(Weight::from_parts(0, 3517))
+			.saturating_add(T::DbWeight::get().reads(1))
+			.saturating_add(T::DbWeight::get().writes(1))
+	}
+	/// Storage: `MessageQueue::Pages` (r:1 w:1)
+	/// Proof: `MessageQueue::Pages` (`max_values`: None, `max_size`: Some(105521), added: 107996, mode: `MaxEncodedLen`)
+	fn service_page_base_completion() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `72`
+		//  Estimated: `108986`
+		// Minimum execution time: 6_433_000 picoseconds.
+		Weight::from_parts(6_823_000, 0)
+			.saturating_add(Weight::from_parts(0, 108986))
+			.saturating_add(T::DbWeight::get().reads(1))
+			.saturating_add(T::DbWeight::get().writes(1))
+	}
+	/// Storage: `MessageQueue::Pages` (r:1 w:1)
+	/// Proof: `MessageQueue::Pages` (`max_values`: None, `max_size`: Some(105521), added: 107996, mode: `MaxEncodedLen`)
+	fn service_page_base_no_completion() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `72`
+		//  Estimated: `108986`
+		// Minimum execution time: 6_457_000 picoseconds.
+		Weight::from_parts(7_044_000, 0)
+			.saturating_add(Weight::from_parts(0, 108986))
+			.saturating_add(T::DbWeight::get().reads(1))
+			.saturating_add(T::DbWeight::get().writes(1))
+	}
+	/// Storage: `MessageQueue::BookStateFor` (r:0 w:1)
+	/// Proof: `MessageQueue::BookStateFor` (`max_values`: None, `max_size`: Some(52), added: 2527, mode: `MaxEncodedLen`)
+	/// Storage: `MessageQueue::Pages` (r:0 w:1)
+	/// Proof: `MessageQueue::Pages` (`max_values`: None, `max_size`: Some(105521), added: 107996, mode: `MaxEncodedLen`)
+	fn service_page_item() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0`
+		//  Estimated: `0`
+		// Minimum execution time: 289_599_000 picoseconds.
+		Weight::from_parts(298_013_000, 0)
+			.saturating_add(Weight::from_parts(0, 0))
+			.saturating_add(T::DbWeight::get().writes(2))
+	}
+	/// Storage: `MessageQueue::ServiceHead` (r:1 w:1)
+	/// Proof: `MessageQueue::ServiceHead` (`max_values`: Some(1), `max_size`: Some(5), added: 500, mode: `MaxEncodedLen`)
+	/// Storage: `MessageQueue::BookStateFor` (r:1 w:0)
+	/// Proof: `MessageQueue::BookStateFor` (`max_values`: None, `max_size`: Some(52), added: 2527, mode: `MaxEncodedLen`)
+	fn bump_service_head() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `171`
+		//  Estimated: `3517`
+		// Minimum execution time: 7_791_000 picoseconds.
+		Weight::from_parts(8_120_000, 0)
+			.saturating_add(Weight::from_parts(0, 3517))
+			.saturating_add(T::DbWeight::get().reads(2))
+			.saturating_add(T::DbWeight::get().writes(1))
+	}
+	/// Storage: `MessageQueue::BookStateFor` (r:1 w:0)
+	/// Proof: `MessageQueue::BookStateFor` (`max_values`: None, `max_size`: Some(52), added: 2527, mode: `MaxEncodedLen`)
+	/// Storage: `MessageQueue::ServiceHead` (r:0 w:1)
+	/// Proof: `MessageQueue::ServiceHead` (`max_values`: Some(1), `max_size`: Some(5), added: 500, mode: `MaxEncodedLen`)
+	fn set_service_head() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `161`
+		//  Estimated: `3517`
+		// Minimum execution time: 6_337_000 picoseconds.
+		Weight::from_parts(6_671_000, 0)
+			.saturating_add(Weight::from_parts(0, 3517))
+			.saturating_add(T::DbWeight::get().reads(1))
+			.saturating_add(T::DbWeight::get().writes(1))
+	}
+	/// Storage: `MessageQueue::BookStateFor` (r:1 w:1)
+	/// Proof: `MessageQueue::BookStateFor` (`max_values`: None, `max_size`: Some(52), added: 2527, mode: `MaxEncodedLen`)
+	/// Storage: `MessageQueue::Pages` (r:1 w:1)
+	/// Proof: `MessageQueue::Pages` (`max_values`: None, `max_size`: Some(105521), added: 107996, mode: `MaxEncodedLen`)
+	fn reap_page() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `105609`
+		//  Estimated: `108986`
+		// Minimum execution time: 112_313_000 picoseconds.
+		Weight::from_parts(113_580_000, 0)
+			.saturating_add(Weight::from_parts(0, 108986))
+			.saturating_add(T::DbWeight::get().reads(2))
+			.saturating_add(T::DbWeight::get().writes(2))
+	}
+	/// Storage: `MessageQueue::BookStateFor` (r:1 w:1)
+	/// Proof: `MessageQueue::BookStateFor` (`max_values`: None, `max_size`: Some(52), added: 2527, mode: `MaxEncodedLen`)
+	/// Storage: `MessageQueue::Pages` (r:1 w:1)
+	/// Proof: `MessageQueue::Pages` (`max_values`: None, `max_size`: Some(105521), added: 107996, mode: `MaxEncodedLen`)
+	fn execute_overweight_page_removed() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `105609`
+		//  Estimated: `108986`
+		// Minimum execution time: 142_383_000 picoseconds.
+		Weight::from_parts(144_443_000, 0)
+			.saturating_add(Weight::from_parts(0, 108986))
+			.saturating_add(T::DbWeight::get().reads(2))
+			.saturating_add(T::DbWeight::get().writes(2))
+	}
+	/// Storage: `MessageQueue::BookStateFor` (r:1 w:1)
+	/// Proof: `MessageQueue::BookStateFor` (`max_values`: None, `max_size`: Some(52), added: 2527, mode: `MaxEncodedLen`)
+	/// Storage: `MessageQueue::Pages` (r:1 w:1)
+	/// Proof: `MessageQueue::Pages` (`max_values`: None, `max_size`: Some(105521), added: 107996, mode: `MaxEncodedLen`)
+	fn execute_overweight_page_updated() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `105609`
+		//  Estimated: `108986`
+		// Minimum execution time: 204_483_000 picoseconds.
+		Weight::from_parts(210_871_000, 0)
+			.saturating_add(Weight::from_parts(0, 108986))
+			.saturating_add(T::DbWeight::get().reads(2))
+			.saturating_add(T::DbWeight::get().writes(2))
+	}
+}

pezcumulus/teyrchains/runtimes/people/people-pezkuwichain/src/weights/pallet_migrations.rs

@@ -0,0 +1,224 @@
+// 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_migrations`
+//!
+//! 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: `afc679a858d4`, 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/people-pezkuwichain-runtime/people_pezkuwichain_runtime.wasm
+// --pallet=pezpallet_migrations
+// --header=/__w/pezkuwi-sdk/pezkuwi-sdk/pezcumulus/file_header.txt
+// --output=./pezcumulus/teyrchains/runtimes/people/people-pezkuwichain/src/weights
+// --wasm-execution=compiled
+// --steps=50
+// --repeat=20
+// --heap-pages=4096
+// --no-storage-info
+// --no-min-squares
+// --no-median-slopes
+
+#![cfg_attr(rustfmt, rustfmt_skip)]
+#![allow(unused_parens)]
+#![allow(unused_imports)]
+#![allow(missing_docs)]
+
+use pezframe_support::{traits::Get, weights::Weight};
+use core::marker::PhantomData;
+
+/// Weight functions for `pezpallet_migrations`.
+pub struct WeightInfo<T>(PhantomData<T>);
+impl<T: pezframe_system::Config> pezpallet_migrations::WeightInfo for WeightInfo<T> {
+	/// Storage: `MultiBlockMigrations::Cursor` (r:1 w:1)
+	/// Proof: `MultiBlockMigrations::Cursor` (`max_values`: Some(1), `max_size`: Some(65550), added: 66045, mode: `MaxEncodedLen`)
+	/// Storage: UNKNOWN KEY `0x583359fe0e84d953a9dd84e8addb08a5` (r:1 w:0)
+	/// Proof: UNKNOWN KEY `0x583359fe0e84d953a9dd84e8addb08a5` (r:1 w:0)
+	fn onboard_new_mbms() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `71`
+		//  Estimated: `67035`
+		// Minimum execution time: 8_430_000 picoseconds.
+		Weight::from_parts(8_626_000, 0)
+			.saturating_add(Weight::from_parts(0, 67035))
+			.saturating_add(T::DbWeight::get().reads(2))
+			.saturating_add(T::DbWeight::get().writes(1))
+	}
+	/// Storage: `MultiBlockMigrations::Cursor` (r:1 w:0)
+	/// Proof: `MultiBlockMigrations::Cursor` (`max_values`: Some(1), `max_size`: Some(65550), added: 66045, mode: `MaxEncodedLen`)
+	fn progress_mbms_none() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `42`
+		//  Estimated: `67035`
+		// Minimum execution time: 2_717_000 picoseconds.
+		Weight::from_parts(2_849_000, 0)
+			.saturating_add(Weight::from_parts(0, 67035))
+			.saturating_add(T::DbWeight::get().reads(1))
+	}
+	/// Storage: UNKNOWN KEY `0x583359fe0e84d953a9dd84e8addb08a5` (r:1 w:0)
+	/// Proof: UNKNOWN KEY `0x583359fe0e84d953a9dd84e8addb08a5` (r:1 w:0)
+	/// Storage: `MultiBlockMigrations::Cursor` (r:0 w:1)
+	/// Proof: `MultiBlockMigrations::Cursor` (`max_values`: Some(1), `max_size`: Some(65550), added: 66045, mode: `MaxEncodedLen`)
+	fn exec_migration_completed() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `29`
+		//  Estimated: `3494`
+		// Minimum execution time: 5_991_000 picoseconds.
+		Weight::from_parts(6_200_000, 0)
+			.saturating_add(Weight::from_parts(0, 3494))
+			.saturating_add(T::DbWeight::get().reads(1))
+			.saturating_add(T::DbWeight::get().writes(1))
+	}
+	/// Storage: UNKNOWN KEY `0x583359fe0e84d953a9dd84e8addb08a5` (r:1 w:0)
+	/// Proof: UNKNOWN KEY `0x583359fe0e84d953a9dd84e8addb08a5` (r:1 w:0)
+	/// Storage: `MultiBlockMigrations::Historic` (r:1 w:0)
+	/// Proof: `MultiBlockMigrations::Historic` (`max_values`: None, `max_size`: Some(266), added: 2741, mode: `MaxEncodedLen`)
+	fn exec_migration_skipped_historic() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `125`
+		//  Estimated: `3731`
+		// Minimum execution time: 11_447_000 picoseconds.
+		Weight::from_parts(11_825_000, 0)
+			.saturating_add(Weight::from_parts(0, 3731))
+			.saturating_add(T::DbWeight::get().reads(2))
+	}
+	/// Storage: UNKNOWN KEY `0x583359fe0e84d953a9dd84e8addb08a5` (r:1 w:0)
+	/// Proof: UNKNOWN KEY `0x583359fe0e84d953a9dd84e8addb08a5` (r:1 w:0)
+	/// Storage: `MultiBlockMigrations::Historic` (r:1 w:0)
+	/// Proof: `MultiBlockMigrations::Historic` (`max_values`: None, `max_size`: Some(266), added: 2741, mode: `MaxEncodedLen`)
+	fn exec_migration_advance() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `71`
+		//  Estimated: `3731`
+		// Minimum execution time: 11_096_000 picoseconds.
+		Weight::from_parts(11_324_000, 0)
+			.saturating_add(Weight::from_parts(0, 3731))
+			.saturating_add(T::DbWeight::get().reads(2))
+	}
+	/// Storage: UNKNOWN KEY `0x583359fe0e84d953a9dd84e8addb08a5` (r:1 w:0)
+	/// Proof: UNKNOWN KEY `0x583359fe0e84d953a9dd84e8addb08a5` (r:1 w:0)
+	/// Storage: `MultiBlockMigrations::Historic` (r:1 w:1)
+	/// Proof: `MultiBlockMigrations::Historic` (`max_values`: None, `max_size`: Some(266), added: 2741, mode: `MaxEncodedLen`)
+	fn exec_migration_complete() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `71`
+		//  Estimated: `3731`
+		// Minimum execution time: 12_627_000 picoseconds.
+		Weight::from_parts(13_076_000, 0)
+			.saturating_add(Weight::from_parts(0, 3731))
+			.saturating_add(T::DbWeight::get().reads(2))
+			.saturating_add(T::DbWeight::get().writes(1))
+	}
+	/// Storage: UNKNOWN KEY `0x583359fe0e84d953a9dd84e8addb08a5` (r:1 w:0)
+	/// Proof: UNKNOWN KEY `0x583359fe0e84d953a9dd84e8addb08a5` (r:1 w:0)
+	/// Storage: `MultiBlockMigrations::Historic` (r:1 w:0)
+	/// Proof: `MultiBlockMigrations::Historic` (`max_values`: None, `max_size`: Some(266), added: 2741, mode: `MaxEncodedLen`)
+	/// Storage: `MultiBlockMigrations::Cursor` (r:0 w:1)
+	/// Proof: `MultiBlockMigrations::Cursor` (`max_values`: Some(1), `max_size`: Some(65550), added: 66045, mode: `MaxEncodedLen`)
+	fn exec_migration_fail() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `71`
+		//  Estimated: `3731`
+		// Minimum execution time: 13_532_000 picoseconds.
+		Weight::from_parts(13_887_000, 0)
+			.saturating_add(Weight::from_parts(0, 3731))
+			.saturating_add(T::DbWeight::get().reads(2))
+			.saturating_add(T::DbWeight::get().writes(1))
+	}
+	fn on_init_loop() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0`
+		//  Estimated: `0`
+		// Minimum execution time: 195_000 picoseconds.
+		Weight::from_parts(220_000, 0)
+			.saturating_add(Weight::from_parts(0, 0))
+	}
+	/// Storage: `MultiBlockMigrations::Cursor` (r:0 w:1)
+	/// Proof: `MultiBlockMigrations::Cursor` (`max_values`: Some(1), `max_size`: Some(65550), added: 66045, mode: `MaxEncodedLen`)
+	fn force_set_cursor() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0`
+		//  Estimated: `0`
+		// Minimum execution time: 2_677_000 picoseconds.
+		Weight::from_parts(2_965_000, 0)
+			.saturating_add(Weight::from_parts(0, 0))
+			.saturating_add(T::DbWeight::get().writes(1))
+	}
+	/// Storage: `MultiBlockMigrations::Cursor` (r:0 w:1)
+	/// Proof: `MultiBlockMigrations::Cursor` (`max_values`: Some(1), `max_size`: Some(65550), added: 66045, mode: `MaxEncodedLen`)
+	fn force_set_active_cursor() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0`
+		//  Estimated: `0`
+		// Minimum execution time: 3_143_000 picoseconds.
+		Weight::from_parts(3_356_000, 0)
+			.saturating_add(Weight::from_parts(0, 0))
+			.saturating_add(T::DbWeight::get().writes(1))
+	}
+	/// Storage: `MultiBlockMigrations::Cursor` (r:1 w:0)
+	/// Proof: `MultiBlockMigrations::Cursor` (`max_values`: Some(1), `max_size`: Some(65550), added: 66045, mode: `MaxEncodedLen`)
+	/// Storage: UNKNOWN KEY `0x583359fe0e84d953a9dd84e8addb08a5` (r:1 w:0)
+	/// Proof: UNKNOWN KEY `0x583359fe0e84d953a9dd84e8addb08a5` (r:1 w:0)
+	fn force_onboard_mbms() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `85`
+		//  Estimated: `67035`
+		// Minimum execution time: 6_844_000 picoseconds.
+		Weight::from_parts(7_095_000, 0)
+			.saturating_add(Weight::from_parts(0, 67035))
+			.saturating_add(T::DbWeight::get().reads(2))
+	}
+	/// Storage: `MultiBlockMigrations::Historic` (r:256 w:256)
+	/// Proof: `MultiBlockMigrations::Historic` (`max_values`: None, `max_size`: Some(266), added: 2741, mode: `MaxEncodedLen`)
+	/// The range of component `n` is `[0, 256]`.
+	fn clear_historic(n: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `1022 + n * (271 ±0)`
+		//  Estimated: `3834 + n * (2740 ±0)`
+		// Minimum execution time: 16_491_000 picoseconds.
+		Weight::from_parts(15_159_833, 0)
+			.saturating_add(Weight::from_parts(0, 3834))
+			// Standard Error: 3_053
+			.saturating_add(Weight::from_parts(1_456_192, 0).saturating_mul(n.into()))
+			.saturating_add(T::DbWeight::get().reads(1))
+			.saturating_add(T::DbWeight::get().reads((1_u64).saturating_mul(n.into())))
+			.saturating_add(T::DbWeight::get().writes((1_u64).saturating_mul(n.into())))
+			.saturating_add(Weight::from_parts(0, 2740).saturating_mul(n.into()))
+	}
+	/// Storage: `Skipped::Metadata` (r:0 w:0)
+	/// Proof: `Skipped::Metadata` (`max_values`: None, `max_size`: None, mode: `Measured`)
+	/// The range of component `n` is `[0, 2048]`.
+	fn reset_pallet_migration(n: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `1642 + n * (38 ±0)`
+		//  Estimated: `720 + n * (39 ±0)`
+		// Minimum execution time: 1_861_000 picoseconds.
+		Weight::from_parts(8_542_096, 0)
+			.saturating_add(Weight::from_parts(0, 720))
+			// Standard Error: 1_577
+			.saturating_add(Weight::from_parts(844_168, 0).saturating_mul(n.into()))
+			.saturating_add(T::DbWeight::get().reads((1_u64).saturating_mul(n.into())))
+			.saturating_add(T::DbWeight::get().writes((1_u64).saturating_mul(n.into())))
+			.saturating_add(Weight::from_parts(0, 39).saturating_mul(n.into()))
+	}
+}

pezcumulus/teyrchains/runtimes/people/people-pezkuwichain/src/weights/pallet_multisig.rs

@@ -0,0 +1,180 @@
+// 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_multisig`
+//!
+//! THIS FILE WAS AUTO-GENERATED USING THE BIZINIKIWI BENCHMARK CLI VERSION 32.0.0
+//! DATE: 2025-02-25, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]`
+//! WORST CASE MAP SIZE: `1000000`
+//! HOSTNAME: `c8c7296f7413`, 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/people-pezkuwichain-runtime/people_pezkuwichain_runtime.wasm
+// --pallet=pezpallet_multisig
+// --header=/__w/pezkuwi-sdk/pezkuwi-sdk/pezcumulus/file_header.txt
+// --output=./pezcumulus/teyrchains/runtimes/people/people-pezkuwichain/src/weights
+// --wasm-execution=compiled
+// --steps=50
+// --repeat=20
+// --heap-pages=4096
+// --no-storage-info
+// --no-min-squares
+// --no-median-slopes
+
+#![cfg_attr(rustfmt, rustfmt_skip)]
+#![allow(unused_parens)]
+#![allow(unused_imports)]
+#![allow(missing_docs)]
+
+use pezframe_support::{traits::Get, weights::Weight};
+use core::marker::PhantomData;
+
+/// Weight functions for `pezpallet_multisig`.
+pub struct WeightInfo<T>(PhantomData<T>);
+impl<T: pezframe_system::Config> pezpallet_multisig::WeightInfo for WeightInfo<T> {
+	/// The range of component `z` is `[0, 10000]`.
+	fn as_multi_threshold_1(z: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0`
+		//  Estimated: `0`
+		// Minimum execution time: 15_740_000 picoseconds.
+		Weight::from_parts(16_129_400, 0)
+			.saturating_add(Weight::from_parts(0, 0))
+			// Standard Error: 18
+			.saturating_add(Weight::from_parts(949, 0).saturating_mul(z.into()))
+	}
+	/// Storage: `Multisig::Multisigs` (r:1 w:1)
+	/// Proof: `Multisig::Multisigs` (`max_values`: None, `max_size`: Some(3346), added: 5821, mode: `MaxEncodedLen`)
+	/// The range of component `s` is `[2, 100]`.
+	/// The range of component `z` is `[0, 10000]`.
+	fn as_multi_create(s: u32, z: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `262 + s * (2 ±0)`
+		//  Estimated: `6811`
+		// Minimum execution time: 47_726_000 picoseconds.
+		Weight::from_parts(42_770_458, 0)
+			.saturating_add(Weight::from_parts(0, 6811))
+			// Standard Error: 5_216
+			.saturating_add(Weight::from_parts(92_088, 0).saturating_mul(s.into()))
+			// Standard Error: 51
+			.saturating_add(Weight::from_parts(1_836, 0).saturating_mul(z.into()))
+			.saturating_add(T::DbWeight::get().reads(1))
+			.saturating_add(T::DbWeight::get().writes(1))
+	}
+	/// Storage: `Multisig::Multisigs` (r:1 w:1)
+	/// Proof: `Multisig::Multisigs` (`max_values`: None, `max_size`: Some(3346), added: 5821, mode: `MaxEncodedLen`)
+	/// The range of component `s` is `[3, 100]`.
+	/// The range of component `z` is `[0, 10000]`.
+	fn as_multi_approve(s: u32, z: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `282`
+		//  Estimated: `6811`
+		// Minimum execution time: 30_839_000 picoseconds.
+		Weight::from_parts(17_024_830, 0)
+			.saturating_add(Weight::from_parts(0, 6811))
+			// Standard Error: 1_897
+			.saturating_add(Weight::from_parts(152_893, 0).saturating_mul(s.into()))
+			// Standard Error: 18
+			.saturating_add(Weight::from_parts(2_077, 0).saturating_mul(z.into()))
+			.saturating_add(T::DbWeight::get().reads(1))
+			.saturating_add(T::DbWeight::get().writes(1))
+	}
+	/// Storage: `Multisig::Multisigs` (r:1 w:1)
+	/// Proof: `Multisig::Multisigs` (`max_values`: None, `max_size`: Some(3346), added: 5821, mode: `MaxEncodedLen`)
+	/// Storage: `System::Account` (r:1 w:1)
+	/// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `MaxEncodedLen`)
+	/// The range of component `s` is `[2, 100]`.
+	/// The range of component `z` is `[0, 10000]`.
+	fn as_multi_complete(s: u32, z: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `385 + s * (33 ±0)`
+		//  Estimated: `6811`
+		// Minimum execution time: 51_336_000 picoseconds.
+		Weight::from_parts(33_150_111, 0)
+			.saturating_add(Weight::from_parts(0, 6811))
+			// Standard Error: 2_792
+			.saturating_add(Weight::from_parts(210_323, 0).saturating_mul(s.into()))
+			// Standard Error: 27
+			.saturating_add(Weight::from_parts(2_275, 0).saturating_mul(z.into()))
+			.saturating_add(T::DbWeight::get().reads(2))
+			.saturating_add(T::DbWeight::get().writes(2))
+	}
+	/// Storage: `Multisig::Multisigs` (r:1 w:1)
+	/// Proof: `Multisig::Multisigs` (`max_values`: None, `max_size`: Some(3346), added: 5821, mode: `MaxEncodedLen`)
+	/// The range of component `s` is `[2, 100]`.
+	fn approve_as_multi_create(s: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `263 + s * (2 ±0)`
+		//  Estimated: `6811`
+		// Minimum execution time: 29_377_000 picoseconds.
+		Weight::from_parts(31_278_890, 0)
+			.saturating_add(Weight::from_parts(0, 6811))
+			// Standard Error: 1_426
+			.saturating_add(Weight::from_parts(167_735, 0).saturating_mul(s.into()))
+			.saturating_add(T::DbWeight::get().reads(1))
+			.saturating_add(T::DbWeight::get().writes(1))
+	}
+	/// Storage: `Multisig::Multisigs` (r:1 w:1)
+	/// Proof: `Multisig::Multisigs` (`max_values`: None, `max_size`: Some(3346), added: 5821, mode: `MaxEncodedLen`)
+	/// The range of component `s` is `[2, 100]`.
+	fn approve_as_multi_approve(s: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `282`
+		//  Estimated: `6811`
+		// Minimum execution time: 16_734_000 picoseconds.
+		Weight::from_parts(18_265_217, 0)
+			.saturating_add(Weight::from_parts(0, 6811))
+			// Standard Error: 1_209
+			.saturating_add(Weight::from_parts(133_740, 0).saturating_mul(s.into()))
+			.saturating_add(T::DbWeight::get().reads(1))
+			.saturating_add(T::DbWeight::get().writes(1))
+	}
+	/// Storage: `Multisig::Multisigs` (r:1 w:1)
+	/// Proof: `Multisig::Multisigs` (`max_values`: None, `max_size`: Some(3346), added: 5821, mode: `MaxEncodedLen`)
+	/// The range of component `s` is `[2, 100]`.
+	fn cancel_as_multi(s: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `454 + s * (1 ±0)`
+		//  Estimated: `6811`
+		// Minimum execution time: 30_167_000 picoseconds.
+		Weight::from_parts(32_070_456, 0)
+			.saturating_add(Weight::from_parts(0, 6811))
+			// Standard Error: 1_666
+			.saturating_add(Weight::from_parts(163_065, 0).saturating_mul(s.into()))
+			.saturating_add(T::DbWeight::get().reads(1))
+			.saturating_add(T::DbWeight::get().writes(1))
+	}
+	/// Storage: `Multisig::Multisigs` (r:1 w:1)
+	/// Proof: `Multisig::Multisigs` (`max_values`: None, `max_size`: Some(3346), added: 5821, mode: `MaxEncodedLen`)
+	/// The range of component `s` is `[2, 100]`.
+	fn poke_deposit(s: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `454 + s * (1 ±0)`
+		//  Estimated: `6811`
+		// Minimum execution time: 29_156_000 picoseconds.
+		Weight::from_parts(30_828_857, 0)
+			.saturating_add(Weight::from_parts(0, 6811))
+			// Standard Error: 1_194
+			.saturating_add(Weight::from_parts(145_508, 0).saturating_mul(s.into()))
+			.saturating_add(T::DbWeight::get().reads(1))
+			.saturating_add(T::DbWeight::get().writes(1))
+	}
+}

pezcumulus/teyrchains/runtimes/people/people-pezkuwichain/src/weights/pallet_proxy.rs

@@ -0,0 +1,242 @@
+// 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_proxy`
+//!
+//! THIS FILE WAS AUTO-GENERATED USING THE BIZINIKIWI BENCHMARK CLI VERSION 32.0.0
+//! DATE: 2025-03-04, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]`
+//! WORST CASE MAP SIZE: `1000000`
+//! HOSTNAME: `99fc4dfa9c86`, 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/people-pezkuwichain-runtime/people_pezkuwichain_runtime.wasm
+// --pallet=pezpallet_proxy
+// --header=/__w/pezkuwi-sdk/pezkuwi-sdk/pezcumulus/file_header.txt
+// --output=./pezcumulus/teyrchains/runtimes/people/people-pezkuwichain/src/weights
+// --wasm-execution=compiled
+// --steps=50
+// --repeat=20
+// --heap-pages=4096
+// --no-storage-info
+// --no-min-squares
+// --no-median-slopes
+
+#![cfg_attr(rustfmt, rustfmt_skip)]
+#![allow(unused_parens)]
+#![allow(unused_imports)]
+#![allow(missing_docs)]
+
+use pezframe_support::{traits::Get, weights::Weight};
+use core::marker::PhantomData;
+
+/// Weight functions for `pezpallet_proxy`.
+pub struct WeightInfo<T>(PhantomData<T>);
+impl<T: pezframe_system::Config> pezpallet_proxy::WeightInfo for WeightInfo<T> {
+	/// Storage: `Proxy::Proxies` (r:1 w:0)
+	/// Proof: `Proxy::Proxies` (`max_values`: None, `max_size`: Some(1241), added: 3716, mode: `MaxEncodedLen`)
+	/// The range of component `p` is `[1, 31]`.
+	fn proxy(p: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `127 + p * (37 ±0)`
+		//  Estimated: `4706`
+		// Minimum execution time: 14_193_000 picoseconds.
+		Weight::from_parts(14_814_540, 0)
+			.saturating_add(Weight::from_parts(0, 4706))
+			// Standard Error: 1_163
+			.saturating_add(Weight::from_parts(25_891, 0).saturating_mul(p.into()))
+			.saturating_add(T::DbWeight::get().reads(1))
+	}
+	/// Storage: `Proxy::Proxies` (r:1 w:0)
+	/// Proof: `Proxy::Proxies` (`max_values`: None, `max_size`: Some(1241), added: 3716, mode: `MaxEncodedLen`)
+	/// Storage: `Proxy::Announcements` (r:1 w:1)
+	/// Proof: `Proxy::Announcements` (`max_values`: None, `max_size`: Some(2233), added: 4708, mode: `MaxEncodedLen`)
+	/// Storage: `System::Account` (r:1 w:1)
+	/// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `MaxEncodedLen`)
+	/// The range of component `a` is `[0, 31]`.
+	/// The range of component `p` is `[1, 31]`.
+	fn proxy_announced(a: u32, p: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `454 + a * (68 ±0) + p * (37 ±0)`
+		//  Estimated: `5698`
+		// Minimum execution time: 40_717_000 picoseconds.
+		Weight::from_parts(41_406_158, 0)
+			.saturating_add(Weight::from_parts(0, 5698))
+			// Standard Error: 3_363
+			.saturating_add(Weight::from_parts(149_287, 0).saturating_mul(a.into()))
+			// Standard Error: 3_475
+			.saturating_add(Weight::from_parts(53_202, 0).saturating_mul(p.into()))
+			.saturating_add(T::DbWeight::get().reads(3))
+			.saturating_add(T::DbWeight::get().writes(2))
+	}
+	/// Storage: `Proxy::Announcements` (r:1 w:1)
+	/// Proof: `Proxy::Announcements` (`max_values`: None, `max_size`: Some(2233), added: 4708, mode: `MaxEncodedLen`)
+	/// Storage: `System::Account` (r:1 w:1)
+	/// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `MaxEncodedLen`)
+	/// The range of component `a` is `[0, 31]`.
+	/// The range of component `p` is `[1, 31]`.
+	fn remove_announcement(a: u32, p: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `369 + a * (68 ±0)`
+		//  Estimated: `5698`
+		// Minimum execution time: 25_574_000 picoseconds.
+		Weight::from_parts(25_943_471, 0)
+			.saturating_add(Weight::from_parts(0, 5698))
+			// Standard Error: 1_934
+			.saturating_add(Weight::from_parts(145_112, 0).saturating_mul(a.into()))
+			// Standard Error: 1_998
+			.saturating_add(Weight::from_parts(31_322, 0).saturating_mul(p.into()))
+			.saturating_add(T::DbWeight::get().reads(2))
+			.saturating_add(T::DbWeight::get().writes(2))
+	}
+	/// Storage: `Proxy::Announcements` (r:1 w:1)
+	/// Proof: `Proxy::Announcements` (`max_values`: None, `max_size`: Some(2233), added: 4708, mode: `MaxEncodedLen`)
+	/// Storage: `System::Account` (r:1 w:1)
+	/// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `MaxEncodedLen`)
+	/// The range of component `a` is `[0, 31]`.
+	/// The range of component `p` is `[1, 31]`.
+	fn reject_announcement(a: u32, p: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `369 + a * (68 ±0)`
+		//  Estimated: `5698`
+		// Minimum execution time: 25_649_000 picoseconds.
+		Weight::from_parts(25_882_341, 0)
+			.saturating_add(Weight::from_parts(0, 5698))
+			// Standard Error: 2_025
+			.saturating_add(Weight::from_parts(142_994, 0).saturating_mul(a.into()))
+			// Standard Error: 2_092
+			.saturating_add(Weight::from_parts(34_199, 0).saturating_mul(p.into()))
+			.saturating_add(T::DbWeight::get().reads(2))
+			.saturating_add(T::DbWeight::get().writes(2))
+	}
+	/// Storage: `Proxy::Proxies` (r:1 w:0)
+	/// Proof: `Proxy::Proxies` (`max_values`: None, `max_size`: Some(1241), added: 3716, mode: `MaxEncodedLen`)
+	/// Storage: `Proxy::Announcements` (r:1 w:1)
+	/// Proof: `Proxy::Announcements` (`max_values`: None, `max_size`: Some(2233), added: 4708, mode: `MaxEncodedLen`)
+	/// Storage: `System::Account` (r:1 w:1)
+	/// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `MaxEncodedLen`)
+	/// The range of component `a` is `[0, 31]`.
+	/// The range of component `p` is `[1, 31]`.
+	fn announce(a: u32, p: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `386 + a * (68 ±0) + p * (37 ±0)`
+		//  Estimated: `5698`
+		// Minimum execution time: 37_082_000 picoseconds.
+		Weight::from_parts(37_886_513, 0)
+			.saturating_add(Weight::from_parts(0, 5698))
+			// Standard Error: 3_640
+			.saturating_add(Weight::from_parts(144_359, 0).saturating_mul(a.into()))
+			// Standard Error: 3_760
+			.saturating_add(Weight::from_parts(45_703, 0).saturating_mul(p.into()))
+			.saturating_add(T::DbWeight::get().reads(3))
+			.saturating_add(T::DbWeight::get().writes(2))
+	}
+	/// Storage: `Proxy::Proxies` (r:1 w:1)
+	/// Proof: `Proxy::Proxies` (`max_values`: None, `max_size`: Some(1241), added: 3716, mode: `MaxEncodedLen`)
+	/// The range of component `p` is `[1, 31]`.
+	fn add_proxy(p: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `127 + p * (37 ±0)`
+		//  Estimated: `4706`
+		// Minimum execution time: 23_957_000 picoseconds.
+		Weight::from_parts(24_927_975, 0)
+			.saturating_add(Weight::from_parts(0, 4706))
+			// Standard Error: 1_758
+			.saturating_add(Weight::from_parts(43_725, 0).saturating_mul(p.into()))
+			.saturating_add(T::DbWeight::get().reads(1))
+			.saturating_add(T::DbWeight::get().writes(1))
+	}
+	/// Storage: `Proxy::Proxies` (r:1 w:1)
+	/// Proof: `Proxy::Proxies` (`max_values`: None, `max_size`: Some(1241), added: 3716, mode: `MaxEncodedLen`)
+	/// The range of component `p` is `[1, 31]`.
+	fn remove_proxy(p: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `127 + p * (37 ±0)`
+		//  Estimated: `4706`
+		// Minimum execution time: 23_729_000 picoseconds.
+		Weight::from_parts(24_583_323, 0)
+			.saturating_add(Weight::from_parts(0, 4706))
+			// Standard Error: 1_400
+			.saturating_add(Weight::from_parts(45_509, 0).saturating_mul(p.into()))
+			.saturating_add(T::DbWeight::get().reads(1))
+			.saturating_add(T::DbWeight::get().writes(1))
+	}
+	/// Storage: `Proxy::Proxies` (r:1 w:1)
+	/// Proof: `Proxy::Proxies` (`max_values`: None, `max_size`: Some(1241), added: 3716, mode: `MaxEncodedLen`)
+	/// The range of component `p` is `[1, 31]`.
+	fn remove_proxies(p: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `127 + p * (37 ±0)`
+		//  Estimated: `4706`
+		// Minimum execution time: 21_192_000 picoseconds.
+		Weight::from_parts(21_995_477, 0)
+			.saturating_add(Weight::from_parts(0, 4706))
+			// Standard Error: 1_926
+			.saturating_add(Weight::from_parts(34_525, 0).saturating_mul(p.into()))
+			.saturating_add(T::DbWeight::get().reads(1))
+			.saturating_add(T::DbWeight::get().writes(1))
+	}
+	/// Storage: `Proxy::Proxies` (r:1 w:1)
+	/// Proof: `Proxy::Proxies` (`max_values`: None, `max_size`: Some(1241), added: 3716, mode: `MaxEncodedLen`)
+	/// The range of component `p` is `[1, 31]`.
+	fn create_pure(p: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `139`
+		//  Estimated: `4706`
+		// Minimum execution time: 25_253_000 picoseconds.
+		Weight::from_parts(26_188_295, 0)
+			.saturating_add(Weight::from_parts(0, 4706))
+			// Standard Error: 1_659
+			.saturating_add(Weight::from_parts(22_321, 0).saturating_mul(p.into()))
+			.saturating_add(T::DbWeight::get().reads(1))
+			.saturating_add(T::DbWeight::get().writes(1))
+	}
+	/// Storage: `Proxy::Proxies` (r:1 w:1)
+	/// Proof: `Proxy::Proxies` (`max_values`: None, `max_size`: Some(1241), added: 3716, mode: `MaxEncodedLen`)
+	/// The range of component `p` is `[0, 30]`.
+	fn kill_pure(p: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `164 + p * (37 ±0)`
+		//  Estimated: `4706`
+		// Minimum execution time: 22_278_000 picoseconds.
+		Weight::from_parts(23_226_079, 0)
+			.saturating_add(Weight::from_parts(0, 4706))
+			// Standard Error: 1_375
+			.saturating_add(Weight::from_parts(23_729, 0).saturating_mul(p.into()))
+			.saturating_add(T::DbWeight::get().reads(1))
+			.saturating_add(T::DbWeight::get().writes(1))
+	}
+	/// Storage: `Proxy::Proxies` (r:1 w:1)
+	/// Proof: `Proxy::Proxies` (`max_values`: None, `max_size`: Some(1241), added: 3716, mode: `MaxEncodedLen`)
+	/// Storage: `System::Account` (r:1 w:1)
+	/// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `MaxEncodedLen`)
+	/// Storage: `Proxy::Announcements` (r:1 w:1)
+	/// Proof: `Proxy::Announcements` (`max_values`: None, `max_size`: Some(2233), added: 4708, mode: `MaxEncodedLen`)
+	fn poke_deposit() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `453`
+		//  Estimated: `5698`
+		// Minimum execution time: 43_833_000 picoseconds.
+		Weight::from_parts(44_489_000, 0)
+			.saturating_add(Weight::from_parts(0, 5698))
+			.saturating_add(T::DbWeight::get().reads(3))
+			.saturating_add(T::DbWeight::get().writes(3))
+	}
+}

pezcumulus/teyrchains/runtimes/people/people-pezkuwichain/src/weights/pallet_session.rs

@@ -0,0 +1,81 @@
+// 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_session`
+//!
+//! 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: `afc679a858d4`, 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/people-pezkuwichain-runtime/people_pezkuwichain_runtime.wasm
+// --pallet=pezpallet_session
+// --header=/__w/pezkuwi-sdk/pezkuwi-sdk/pezcumulus/file_header.txt
+// --output=./pezcumulus/teyrchains/runtimes/people/people-pezkuwichain/src/weights
+// --wasm-execution=compiled
+// --steps=50
+// --repeat=20
+// --heap-pages=4096
+// --no-storage-info
+// --no-min-squares
+// --no-median-slopes
+
+#![cfg_attr(rustfmt, rustfmt_skip)]
+#![allow(unused_parens)]
+#![allow(unused_imports)]
+#![allow(missing_docs)]
+
+use pezframe_support::{traits::Get, weights::Weight};
+use core::marker::PhantomData;
+
+/// Weight functions for `pezpallet_session`.
+pub struct WeightInfo<T>(PhantomData<T>);
+impl<T: pezframe_system::Config> pezpallet_session::WeightInfo for WeightInfo<T> {
+	/// Storage: `Session::NextKeys` (r:1 w:1)
+	/// Proof: `Session::NextKeys` (`max_values`: None, `max_size`: None, mode: `Measured`)
+	/// Storage: `Session::KeyOwner` (r:1 w:1)
+	/// Proof: `Session::KeyOwner` (`max_values`: None, `max_size`: None, mode: `Measured`)
+	fn set_keys() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `271`
+		//  Estimated: `3736`
+		// Minimum execution time: 18_404_000 picoseconds.
+		Weight::from_parts(18_873_000, 0)
+			.saturating_add(Weight::from_parts(0, 3736))
+			.saturating_add(T::DbWeight::get().reads(2))
+			.saturating_add(T::DbWeight::get().writes(2))
+	}
+	/// Storage: `Session::NextKeys` (r:1 w:1)
+	/// Proof: `Session::NextKeys` (`max_values`: None, `max_size`: None, mode: `Measured`)
+	/// Storage: `Session::KeyOwner` (r:0 w:1)
+	/// Proof: `Session::KeyOwner` (`max_values`: None, `max_size`: None, mode: `Measured`)
+	fn purge_keys() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `243`
+		//  Estimated: `3708`
+		// Minimum execution time: 13_408_000 picoseconds.
+		Weight::from_parts(13_766_000, 0)
+			.saturating_add(Weight::from_parts(0, 3708))
+			.saturating_add(T::DbWeight::get().reads(1))
+			.saturating_add(T::DbWeight::get().writes(2))
+	}
+}

pezcumulus/teyrchains/runtimes/people/people-pezkuwichain/src/weights/pallet_timestamp.rs

@@ -0,0 +1,75 @@
+// 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: `afc679a858d4`, 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/people-pezkuwichain-runtime/people_pezkuwichain_runtime.wasm
+// --pallet=pezpallet_timestamp
+// --header=/__w/pezkuwi-sdk/pezkuwi-sdk/pezcumulus/file_header.txt
+// --output=./pezcumulus/teyrchains/runtimes/people/people-pezkuwichain/src/weights
+// --wasm-execution=compiled
+// --steps=50
+// --repeat=20
+// --heap-pages=4096
+// --no-storage-info
+// --no-min-squares
+// --no-median-slopes
+
+#![cfg_attr(rustfmt, rustfmt_skip)]
+#![allow(unused_parens)]
+#![allow(unused_imports)]
+#![allow(missing_docs)]
+
+use pezframe_support::{traits::Get, weights::Weight};
+use core::marker::PhantomData;
+
+/// Weight functions for `pezpallet_timestamp`.
+pub struct WeightInfo<T>(PhantomData<T>);
+impl<T: pezframe_system::Config> pezpallet_timestamp::WeightInfo for WeightInfo<T> {
+	/// Storage: `Timestamp::Now` (r:1 w:1)
+	/// Proof: `Timestamp::Now` (`max_values`: Some(1), `max_size`: Some(8), added: 503, mode: `MaxEncodedLen`)
+	/// Storage: `Aura::CurrentSlot` (r:1 w:0)
+	/// Proof: `Aura::CurrentSlot` (`max_values`: Some(1), `max_size`: Some(8), added: 503, mode: `MaxEncodedLen`)
+	fn set() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `85`
+		//  Estimated: `1493`
+		// Minimum execution time: 8_096_000 picoseconds.
+		Weight::from_parts(8_404_000, 0)
+			.saturating_add(Weight::from_parts(0, 1493))
+			.saturating_add(T::DbWeight::get().reads(2))
+			.saturating_add(T::DbWeight::get().writes(1))
+	}
+	fn on_finalize() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `94`
+		//  Estimated: `0`
+		// Minimum execution time: 4_510_000 picoseconds.
+		Weight::from_parts(4_707_000, 0)
+			.saturating_add(Weight::from_parts(0, 0))
+	}
+}

pezcumulus/teyrchains/runtimes/people/people-pezkuwichain/src/weights/pallet_transaction_payment.rs

@@ -0,0 +1,65 @@
+// 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_transaction_payment`
+//!
+//! 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: `afc679a858d4`, 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/people-pezkuwichain-runtime/people_pezkuwichain_runtime.wasm
+// --pallet=pezpallet_transaction_payment
+// --header=/__w/pezkuwi-sdk/pezkuwi-sdk/pezcumulus/file_header.txt
+// --output=./pezcumulus/teyrchains/runtimes/people/people-pezkuwichain/src/weights
+// --wasm-execution=compiled
+// --steps=50
+// --repeat=20
+// --heap-pages=4096
+// --no-storage-info
+// --no-min-squares
+// --no-median-slopes
+
+#![cfg_attr(rustfmt, rustfmt_skip)]
+#![allow(unused_parens)]
+#![allow(unused_imports)]
+#![allow(missing_docs)]
+
+use pezframe_support::{traits::Get, weights::Weight};
+use core::marker::PhantomData;
+
+/// Weight functions for `pezpallet_transaction_payment`.
+pub struct WeightInfo<T>(PhantomData<T>);
+impl<T: pezframe_system::Config> pezpallet_transaction_payment::WeightInfo for WeightInfo<T> {
+	/// Storage: `System::Account` (r:2 w:2)
+	/// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `MaxEncodedLen`)
+	fn charge_transaction_payment() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `101`
+		//  Estimated: `6196`
+		// Minimum execution time: 44_019_000 picoseconds.
+		Weight::from_parts(45_193_000, 0)
+			.saturating_add(Weight::from_parts(0, 6196))
+			.saturating_add(T::DbWeight::get().reads(2))
+			.saturating_add(T::DbWeight::get().writes(2))
+	}
+}

pezcumulus/teyrchains/runtimes/people/people-pezkuwichain/src/weights/pallet_utility.rs

@@ -0,0 +1,118 @@
+// 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_utility`
+//!
+//! 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: `afc679a858d4`, 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/people-pezkuwichain-runtime/people_pezkuwichain_runtime.wasm
+// --pallet=pezpallet_utility
+// --header=/__w/pezkuwi-sdk/pezkuwi-sdk/pezcumulus/file_header.txt
+// --output=./pezcumulus/teyrchains/runtimes/people/people-pezkuwichain/src/weights
+// --wasm-execution=compiled
+// --steps=50
+// --repeat=20
+// --heap-pages=4096
+// --no-storage-info
+// --no-min-squares
+// --no-median-slopes
+
+#![cfg_attr(rustfmt, rustfmt_skip)]
+#![allow(unused_parens)]
+#![allow(unused_imports)]
+#![allow(missing_docs)]
+
+use pezframe_support::{traits::Get, weights::Weight};
+use core::marker::PhantomData;
+
+/// Weight functions for `pezpallet_utility`.
+pub struct WeightInfo<T>(PhantomData<T>);
+impl<T: pezframe_system::Config> pezpallet_utility::WeightInfo for WeightInfo<T> {
+	/// The range of component `c` is `[0, 1000]`.
+	fn batch(c: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0`
+		//  Estimated: `0`
+		// Minimum execution time: 5_054_000 picoseconds.
+		Weight::from_parts(5_176_000, 0)
+			.saturating_add(Weight::from_parts(0, 0))
+			// Standard Error: 715
+			.saturating_add(Weight::from_parts(3_005_267, 0).saturating_mul(c.into()))
+	}
+	fn as_derivative() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0`
+		//  Estimated: `0`
+		// Minimum execution time: 4_581_000 picoseconds.
+		Weight::from_parts(4_788_000, 0)
+			.saturating_add(Weight::from_parts(0, 0))
+	}
+	/// The range of component `c` is `[0, 1000]`.
+	fn batch_all(c: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0`
+		//  Estimated: `0`
+		// Minimum execution time: 5_037_000 picoseconds.
+		Weight::from_parts(5_257_000, 0)
+			.saturating_add(Weight::from_parts(0, 0))
+			// Standard Error: 791
+			.saturating_add(Weight::from_parts(3_206_939, 0).saturating_mul(c.into()))
+	}
+	fn dispatch_as() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0`
+		//  Estimated: `0`
+		// Minimum execution time: 6_872_000 picoseconds.
+		Weight::from_parts(7_124_000, 0)
+			.saturating_add(Weight::from_parts(0, 0))
+	}
+	/// The range of component `c` is `[0, 1000]`.
+	fn force_batch(c: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0`
+		//  Estimated: `0`
+		// Minimum execution time: 5_060_000 picoseconds.
+		Weight::from_parts(5_180_000, 0)
+			.saturating_add(Weight::from_parts(0, 0))
+			// Standard Error: 660
+			.saturating_add(Weight::from_parts(2_996_117, 0).saturating_mul(c.into()))
+	}
+	fn dispatch_as_fallible() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0`
+		//  Estimated: `0`
+		// Minimum execution time: 6_863_000 picoseconds.
+		Weight::from_parts(7_157_000, 0)
+			.saturating_add(Weight::from_parts(0, 0))
+	}
+	fn if_else() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0`
+		//  Estimated: `0`
+		// Minimum execution time: 8_589_000 picoseconds.
+		Weight::from_parts(8_868_000, 0)
+			.saturating_add(Weight::from_parts(0, 0))
+	}
+}

pezcumulus/teyrchains/runtimes/people/people-pezkuwichain/src/weights/pallet_xcm.rs

@@ -0,0 +1,390 @@
+// 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_xcm`
+//!
+//! THIS FILE WAS AUTO-GENERATED USING THE BIZINIKIWI BENCHMARK CLI VERSION 32.0.0
+//! DATE: 2025-07-30, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]`
+//! WORST CASE MAP SIZE: `1000000`
+//! HOSTNAME: `a49f76527979`, 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/people-pezkuwichain-runtime/people_pezkuwichain_runtime.wasm
+// --pallet=pezpallet_xcm
+// --header=/__w/pezkuwi-sdk/pezkuwi-sdk/pezcumulus/file_header.txt
+// --output=./pezcumulus/teyrchains/runtimes/people/people-pezkuwichain/src/weights
+// --wasm-execution=compiled
+// --steps=50
+// --repeat=20
+// --heap-pages=4096
+// --no-storage-info
+// --no-min-squares
+// --no-median-slopes
+
+#![cfg_attr(rustfmt, rustfmt_skip)]
+#![allow(unused_parens)]
+#![allow(unused_imports)]
+#![allow(missing_docs)]
+
+use pezframe_support::{traits::Get, weights::Weight};
+use core::marker::PhantomData;
+
+/// Weight functions for `pezpallet_xcm`.
+pub struct WeightInfo<T>(PhantomData<T>);
+impl<T: pezframe_system::Config> pezpallet_xcm::WeightInfo for WeightInfo<T> {
+	/// Storage: `TeyrchainInfo::TeyrchainId` (r:1 w:0)
+	/// Proof: `TeyrchainInfo::TeyrchainId` (`max_values`: Some(1), `max_size`: Some(4), added: 499, mode: `MaxEncodedLen`)
+	/// Storage: `XcmpQueue::DeliveryFeeFactor` (r:1 w:0)
+	/// Proof: `XcmpQueue::DeliveryFeeFactor` (`max_values`: None, `max_size`: Some(28), added: 2503, mode: `MaxEncodedLen`)
+	/// Storage: `PezkuwiXcm::SupportedVersion` (r:1 w:0)
+	/// Proof: `PezkuwiXcm::SupportedVersion` (`max_values`: None, `max_size`: None, mode: `Measured`)
+	/// Storage: `TeyrchainSystem::RelevantMessagingState` (r:1 w:0)
+	/// Proof: `TeyrchainSystem::RelevantMessagingState` (`max_values`: Some(1), `max_size`: None, mode: `Measured`)
+	/// Storage: `XcmpQueue::OutboundXcmpStatus` (r:1 w:1)
+	/// Proof: `XcmpQueue::OutboundXcmpStatus` (`max_values`: Some(1), `max_size`: Some(1282), added: 1777, mode: `MaxEncodedLen`)
+	/// Storage: `XcmpQueue::OutboundXcmpMessages` (r:0 w:1)
+	/// Proof: `XcmpQueue::OutboundXcmpMessages` (`max_values`: None, `max_size`: Some(105506), added: 107981, mode: `MaxEncodedLen`)
+	fn send() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `244`
+		//  Estimated: `3709`
+		// Minimum execution time: 34_158_000 picoseconds.
+		Weight::from_parts(35_174_000, 0)
+			.saturating_add(Weight::from_parts(0, 3709))
+			.saturating_add(T::DbWeight::get().reads(5))
+			.saturating_add(T::DbWeight::get().writes(2))
+	}
+	/// Storage: `TeyrchainInfo::TeyrchainId` (r:1 w:0)
+	/// Proof: `TeyrchainInfo::TeyrchainId` (`max_values`: Some(1), `max_size`: Some(4), added: 499, mode: `MaxEncodedLen`)
+	/// Storage: `PezkuwiXcm::ShouldRecordXcm` (r:1 w:0)
+	/// Proof: `PezkuwiXcm::ShouldRecordXcm` (`max_values`: Some(1), `max_size`: None, mode: `Measured`)
+	/// Storage: `XcmpQueue::DeliveryFeeFactor` (r:1 w:0)
+	/// Proof: `XcmpQueue::DeliveryFeeFactor` (`max_values`: None, `max_size`: Some(28), added: 2503, mode: `MaxEncodedLen`)
+	/// Storage: `PezkuwiXcm::SupportedVersion` (r:1 w:0)
+	/// Proof: `PezkuwiXcm::SupportedVersion` (`max_values`: None, `max_size`: None, mode: `Measured`)
+	/// Storage: `System::Account` (r:1 w:1)
+	/// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `MaxEncodedLen`)
+	/// Storage: `TeyrchainSystem::RelevantMessagingState` (r:1 w:0)
+	/// Proof: `TeyrchainSystem::RelevantMessagingState` (`max_values`: Some(1), `max_size`: None, mode: `Measured`)
+	/// Storage: `XcmpQueue::OutboundXcmpStatus` (r:1 w:1)
+	/// Proof: `XcmpQueue::OutboundXcmpStatus` (`max_values`: Some(1), `max_size`: Some(1282), added: 1777, mode: `MaxEncodedLen`)
+	/// Storage: `XcmpQueue::OutboundXcmpMessages` (r:0 w:1)
+	/// Proof: `XcmpQueue::OutboundXcmpMessages` (`max_values`: None, `max_size`: Some(105506), added: 107981, mode: `MaxEncodedLen`)
+	fn teleport_assets() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `244`
+		//  Estimated: `3709`
+		// Minimum execution time: 116_998_000 picoseconds.
+		Weight::from_parts(120_674_000, 0)
+			.saturating_add(Weight::from_parts(0, 3709))
+			.saturating_add(T::DbWeight::get().reads(7))
+			.saturating_add(T::DbWeight::get().writes(3))
+	}
+	/// Storage: `Benchmark::Override` (r:0 w:0)
+	/// Proof: `Benchmark::Override` (`max_values`: None, `max_size`: None, mode: `Measured`)
+	fn reserve_transfer_assets() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0`
+		//  Estimated: `0`
+		// Minimum execution time: 18_446_744_073_709_551_000 picoseconds.
+		Weight::from_parts(18_446_744_073_709_551_000, 0)
+			.saturating_add(Weight::from_parts(0, 0))
+	}
+	/// Storage: `TeyrchainInfo::TeyrchainId` (r:1 w:0)
+	/// Proof: `TeyrchainInfo::TeyrchainId` (`max_values`: Some(1), `max_size`: Some(4), added: 499, mode: `MaxEncodedLen`)
+	/// Storage: `PezkuwiXcm::ShouldRecordXcm` (r:1 w:0)
+	/// Proof: `PezkuwiXcm::ShouldRecordXcm` (`max_values`: Some(1), `max_size`: None, mode: `Measured`)
+	/// Storage: `XcmpQueue::DeliveryFeeFactor` (r:1 w:0)
+	/// Proof: `XcmpQueue::DeliveryFeeFactor` (`max_values`: None, `max_size`: Some(28), added: 2503, mode: `MaxEncodedLen`)
+	/// Storage: `PezkuwiXcm::SupportedVersion` (r:1 w:0)
+	/// Proof: `PezkuwiXcm::SupportedVersion` (`max_values`: None, `max_size`: None, mode: `Measured`)
+	/// Storage: `System::Account` (r:1 w:1)
+	/// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `MaxEncodedLen`)
+	/// Storage: `TeyrchainSystem::RelevantMessagingState` (r:1 w:0)
+	/// Proof: `TeyrchainSystem::RelevantMessagingState` (`max_values`: Some(1), `max_size`: None, mode: `Measured`)
+	/// Storage: `XcmpQueue::OutboundXcmpStatus` (r:1 w:1)
+	/// Proof: `XcmpQueue::OutboundXcmpStatus` (`max_values`: Some(1), `max_size`: Some(1282), added: 1777, mode: `MaxEncodedLen`)
+	/// Storage: `XcmpQueue::OutboundXcmpMessages` (r:0 w:1)
+	/// Proof: `XcmpQueue::OutboundXcmpMessages` (`max_values`: None, `max_size`: Some(105506), added: 107981, mode: `MaxEncodedLen`)
+	fn transfer_assets() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `244`
+		//  Estimated: `3709`
+		// Minimum execution time: 116_783_000 picoseconds.
+		Weight::from_parts(121_527_000, 0)
+			.saturating_add(Weight::from_parts(0, 3709))
+			.saturating_add(T::DbWeight::get().reads(7))
+			.saturating_add(T::DbWeight::get().writes(3))
+	}
+	/// Storage: `PezkuwiXcm::ShouldRecordXcm` (r:1 w:0)
+	/// Proof: `PezkuwiXcm::ShouldRecordXcm` (`max_values`: Some(1), `max_size`: None, mode: `Measured`)
+	fn execute() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0`
+		//  Estimated: `1485`
+		// Minimum execution time: 9_424_000 picoseconds.
+		Weight::from_parts(9_737_000, 0)
+			.saturating_add(Weight::from_parts(0, 1485))
+			.saturating_add(T::DbWeight::get().reads(1))
+	}
+	/// Storage: `PezkuwiXcm::SupportedVersion` (r:0 w:1)
+	/// Proof: `PezkuwiXcm::SupportedVersion` (`max_values`: None, `max_size`: None, mode: `Measured`)
+	fn force_xcm_version() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0`
+		//  Estimated: `0`
+		// Minimum execution time: 7_875_000 picoseconds.
+		Weight::from_parts(8_130_000, 0)
+			.saturating_add(Weight::from_parts(0, 0))
+			.saturating_add(T::DbWeight::get().writes(1))
+	}
+	fn force_default_xcm_version() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0`
+		//  Estimated: `0`
+		// Minimum execution time: 2_381_000 picoseconds.
+		Weight::from_parts(2_561_000, 0)
+			.saturating_add(Weight::from_parts(0, 0))
+	}
+	/// Storage: `PezkuwiXcm::VersionNotifiers` (r:1 w:1)
+	/// Proof: `PezkuwiXcm::VersionNotifiers` (`max_values`: None, `max_size`: None, mode: `Measured`)
+	/// Storage: `PezkuwiXcm::QueryCounter` (r:1 w:1)
+	/// Proof: `PezkuwiXcm::QueryCounter` (`max_values`: Some(1), `max_size`: None, mode: `Measured`)
+	/// Storage: `XcmpQueue::DeliveryFeeFactor` (r:1 w:0)
+	/// Proof: `XcmpQueue::DeliveryFeeFactor` (`max_values`: None, `max_size`: Some(28), added: 2503, mode: `MaxEncodedLen`)
+	/// Storage: `PezkuwiXcm::SupportedVersion` (r:1 w:0)
+	/// Proof: `PezkuwiXcm::SupportedVersion` (`max_values`: None, `max_size`: None, mode: `Measured`)
+	/// Storage: `TeyrchainSystem::RelevantMessagingState` (r:1 w:0)
+	/// Proof: `TeyrchainSystem::RelevantMessagingState` (`max_values`: Some(1), `max_size`: None, mode: `Measured`)
+	/// Storage: `XcmpQueue::OutboundXcmpStatus` (r:1 w:1)
+	/// Proof: `XcmpQueue::OutboundXcmpStatus` (`max_values`: Some(1), `max_size`: Some(1282), added: 1777, mode: `MaxEncodedLen`)
+	/// Storage: `XcmpQueue::OutboundXcmpMessages` (r:0 w:1)
+	/// Proof: `XcmpQueue::OutboundXcmpMessages` (`max_values`: None, `max_size`: Some(105506), added: 107981, mode: `MaxEncodedLen`)
+	/// Storage: `PezkuwiXcm::Queries` (r:0 w:1)
+	/// Proof: `PezkuwiXcm::Queries` (`max_values`: None, `max_size`: None, mode: `Measured`)
+	fn force_subscribe_version_notify() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `175`
+		//  Estimated: `3640`
+		// Minimum execution time: 36_927_000 picoseconds.
+		Weight::from_parts(38_308_000, 0)
+			.saturating_add(Weight::from_parts(0, 3640))
+			.saturating_add(T::DbWeight::get().reads(6))
+			.saturating_add(T::DbWeight::get().writes(5))
+	}
+	/// Storage: `PezkuwiXcm::VersionNotifiers` (r:1 w:1)
+	/// Proof: `PezkuwiXcm::VersionNotifiers` (`max_values`: None, `max_size`: None, mode: `Measured`)
+	/// Storage: `XcmpQueue::DeliveryFeeFactor` (r:1 w:0)
+	/// Proof: `XcmpQueue::DeliveryFeeFactor` (`max_values`: None, `max_size`: Some(28), added: 2503, mode: `MaxEncodedLen`)
+	/// Storage: `PezkuwiXcm::SupportedVersion` (r:1 w:0)
+	/// Proof: `PezkuwiXcm::SupportedVersion` (`max_values`: None, `max_size`: None, mode: `Measured`)
+	/// Storage: `TeyrchainSystem::RelevantMessagingState` (r:1 w:0)
+	/// Proof: `TeyrchainSystem::RelevantMessagingState` (`max_values`: Some(1), `max_size`: None, mode: `Measured`)
+	/// Storage: `XcmpQueue::OutboundXcmpStatus` (r:1 w:0)
+	/// Proof: `XcmpQueue::OutboundXcmpStatus` (`max_values`: Some(1), `max_size`: Some(1282), added: 1777, mode: `MaxEncodedLen`)
+	/// Storage: `XcmpQueue::OutboundXcmpMessages` (r:1 w:1)
+	/// Proof: `XcmpQueue::OutboundXcmpMessages` (`max_values`: None, `max_size`: Some(105506), added: 107981, mode: `MaxEncodedLen`)
+	/// Storage: `PezkuwiXcm::Queries` (r:0 w:1)
+	/// Proof: `PezkuwiXcm::Queries` (`max_values`: None, `max_size`: None, mode: `Measured`)
+	fn force_unsubscribe_version_notify() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `334`
+		//  Estimated: `108971`
+		// Minimum execution time: 42_365_000 picoseconds.
+		Weight::from_parts(43_757_000, 0)
+			.saturating_add(Weight::from_parts(0, 108971))
+			.saturating_add(T::DbWeight::get().reads(6))
+			.saturating_add(T::DbWeight::get().writes(3))
+	}
+	/// Storage: `PezkuwiXcm::XcmExecutionSuspended` (r:0 w:1)
+	/// Proof: `PezkuwiXcm::XcmExecutionSuspended` (`max_values`: Some(1), `max_size`: None, mode: `Measured`)
+	fn force_suspension() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0`
+		//  Estimated: `0`
+		// Minimum execution time: 2_365_000 picoseconds.
+		Weight::from_parts(2_499_000, 0)
+			.saturating_add(Weight::from_parts(0, 0))
+			.saturating_add(T::DbWeight::get().writes(1))
+	}
+	/// Storage: `PezkuwiXcm::SupportedVersion` (r:6 w:2)
+	/// Proof: `PezkuwiXcm::SupportedVersion` (`max_values`: None, `max_size`: None, mode: `Measured`)
+	fn migrate_supported_version() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `23`
+		//  Estimated: `15863`
+		// Minimum execution time: 20_424_000 picoseconds.
+		Weight::from_parts(21_184_000, 0)
+			.saturating_add(Weight::from_parts(0, 15863))
+			.saturating_add(T::DbWeight::get().reads(6))
+			.saturating_add(T::DbWeight::get().writes(2))
+	}
+	/// Storage: `PezkuwiXcm::VersionNotifiers` (r:6 w:2)
+	/// Proof: `PezkuwiXcm::VersionNotifiers` (`max_values`: None, `max_size`: None, mode: `Measured`)
+	fn migrate_version_notifiers() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `27`
+		//  Estimated: `15867`
+		// Minimum execution time: 20_641_000 picoseconds.
+		Weight::from_parts(21_383_000, 0)
+			.saturating_add(Weight::from_parts(0, 15867))
+			.saturating_add(T::DbWeight::get().reads(6))
+			.saturating_add(T::DbWeight::get().writes(2))
+	}
+	/// Storage: `PezkuwiXcm::VersionNotifyTargets` (r:7 w:0)
+	/// Proof: `PezkuwiXcm::VersionNotifyTargets` (`max_values`: None, `max_size`: None, mode: `Measured`)
+	fn already_notified_target() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `79`
+		//  Estimated: `18394`
+		// Minimum execution time: 25_931_000 picoseconds.
+		Weight::from_parts(26_547_000, 0)
+			.saturating_add(Weight::from_parts(0, 18394))
+			.saturating_add(T::DbWeight::get().reads(7))
+	}
+	/// Storage: `PezkuwiXcm::VersionNotifyTargets` (r:2 w:1)
+	/// Proof: `PezkuwiXcm::VersionNotifyTargets` (`max_values`: None, `max_size`: None, mode: `Measured`)
+	/// Storage: `XcmpQueue::DeliveryFeeFactor` (r:1 w:0)
+	/// Proof: `XcmpQueue::DeliveryFeeFactor` (`max_values`: None, `max_size`: Some(28), added: 2503, mode: `MaxEncodedLen`)
+	/// Storage: `PezkuwiXcm::SupportedVersion` (r:1 w:0)
+	/// Proof: `PezkuwiXcm::SupportedVersion` (`max_values`: None, `max_size`: None, mode: `Measured`)
+	/// Storage: `TeyrchainSystem::RelevantMessagingState` (r:1 w:0)
+	/// Proof: `TeyrchainSystem::RelevantMessagingState` (`max_values`: Some(1), `max_size`: None, mode: `Measured`)
+	fn notify_current_targets() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `119`
+		//  Estimated: `6059`
+		// Minimum execution time: 35_296_000 picoseconds.
+		Weight::from_parts(36_300_000, 0)
+			.saturating_add(Weight::from_parts(0, 6059))
+			.saturating_add(T::DbWeight::get().reads(5))
+			.saturating_add(T::DbWeight::get().writes(1))
+	}
+	/// Storage: `PezkuwiXcm::VersionNotifyTargets` (r:5 w:0)
+	/// Proof: `PezkuwiXcm::VersionNotifyTargets` (`max_values`: None, `max_size`: None, mode: `Measured`)
+	fn notify_target_migration_fail() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `79`
+		//  Estimated: `13444`
+		// Minimum execution time: 18_067_000 picoseconds.
+		Weight::from_parts(18_628_000, 0)
+			.saturating_add(Weight::from_parts(0, 13444))
+			.saturating_add(T::DbWeight::get().reads(5))
+	}
+	/// Storage: `PezkuwiXcm::VersionNotifyTargets` (r:6 w:2)
+	/// Proof: `PezkuwiXcm::VersionNotifyTargets` (`max_values`: None, `max_size`: None, mode: `Measured`)
+	fn migrate_version_notify_targets() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `34`
+		//  Estimated: `15874`
+		// Minimum execution time: 20_389_000 picoseconds.
+		Weight::from_parts(21_258_000, 0)
+			.saturating_add(Weight::from_parts(0, 15874))
+			.saturating_add(T::DbWeight::get().reads(6))
+			.saturating_add(T::DbWeight::get().writes(2))
+	}
+	/// Storage: `PezkuwiXcm::VersionNotifyTargets` (r:6 w:1)
+	/// Proof: `PezkuwiXcm::VersionNotifyTargets` (`max_values`: None, `max_size`: None, mode: `Measured`)
+	/// Storage: `XcmpQueue::DeliveryFeeFactor` (r:1 w:0)
+	/// Proof: `XcmpQueue::DeliveryFeeFactor` (`max_values`: None, `max_size`: Some(28), added: 2503, mode: `MaxEncodedLen`)
+	/// Storage: `PezkuwiXcm::SupportedVersion` (r:1 w:0)
+	/// Proof: `PezkuwiXcm::SupportedVersion` (`max_values`: None, `max_size`: None, mode: `Measured`)
+	/// Storage: `TeyrchainSystem::RelevantMessagingState` (r:1 w:0)
+	/// Proof: `TeyrchainSystem::RelevantMessagingState` (`max_values`: Some(1), `max_size`: None, mode: `Measured`)
+	fn migrate_and_notify_old_targets() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `119`
+		//  Estimated: `15959`
+		// Minimum execution time: 45_440_000 picoseconds.
+		Weight::from_parts(47_521_000, 0)
+			.saturating_add(Weight::from_parts(0, 15959))
+			.saturating_add(T::DbWeight::get().reads(9))
+			.saturating_add(T::DbWeight::get().writes(1))
+	}
+	/// Storage: `PezkuwiXcm::QueryCounter` (r:1 w:1)
+	/// Proof: `PezkuwiXcm::QueryCounter` (`max_values`: Some(1), `max_size`: None, mode: `Measured`)
+	/// Storage: `PezkuwiXcm::Queries` (r:0 w:1)
+	/// Proof: `PezkuwiXcm::Queries` (`max_values`: None, `max_size`: None, mode: `Measured`)
+	fn new_query() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0`
+		//  Estimated: `1485`
+		// Minimum execution time: 2_671_000 picoseconds.
+		Weight::from_parts(2_797_000, 0)
+			.saturating_add(Weight::from_parts(0, 1485))
+			.saturating_add(T::DbWeight::get().reads(1))
+			.saturating_add(T::DbWeight::get().writes(2))
+	}
+	/// Storage: `PezkuwiXcm::Queries` (r:1 w:1)
+	/// Proof: `PezkuwiXcm::Queries` (`max_values`: None, `max_size`: None, mode: `Measured`)
+	fn take_response() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `7576`
+		//  Estimated: `11041`
+		// Minimum execution time: 27_233_000 picoseconds.
+		Weight::from_parts(27_764_000, 0)
+			.saturating_add(Weight::from_parts(0, 11041))
+			.saturating_add(T::DbWeight::get().reads(1))
+			.saturating_add(T::DbWeight::get().writes(1))
+	}
+	/// Storage: `PezkuwiXcm::ShouldRecordXcm` (r:1 w:0)
+	/// Proof: `PezkuwiXcm::ShouldRecordXcm` (`max_values`: Some(1), `max_size`: None, mode: `Measured`)
+	/// Storage: `PezkuwiXcm::AssetTraps` (r:1 w:1)
+	/// Proof: `PezkuwiXcm::AssetTraps` (`max_values`: None, `max_size`: None, mode: `Measured`)
+	fn claim_assets() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `24`
+		//  Estimated: `3489`
+		// Minimum execution time: 39_700_000 picoseconds.
+		Weight::from_parts(40_687_000, 0)
+			.saturating_add(Weight::from_parts(0, 3489))
+			.saturating_add(T::DbWeight::get().reads(2))
+			.saturating_add(T::DbWeight::get().writes(1))
+	}
+	/// Storage: `Benchmark::Override` (r:0 w:0)
+	/// Proof: `Benchmark::Override` (`max_values`: None, `max_size`: None, mode: `Measured`)
+	fn add_authorized_alias() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0`
+		//  Estimated: `0`
+		// Minimum execution time: 18_446_744_073_709_551_000 picoseconds.
+		Weight::from_parts(18_446_744_073_709_551_000, 0)
+			.saturating_add(Weight::from_parts(0, 0))
+	}
+	/// Storage: `Benchmark::Override` (r:0 w:0)
+	/// Proof: `Benchmark::Override` (`max_values`: None, `max_size`: None, mode: `Measured`)
+	fn remove_authorized_alias() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0`
+		//  Estimated: `0`
+		// Minimum execution time: 18_446_744_073_709_551_000 picoseconds.
+		Weight::from_parts(18_446_744_073_709_551_000, 0)
+			.saturating_add(Weight::from_parts(0, 0))
+	}
+	fn weigh_message() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0`
+		//  Estimated: `0`
+		// Minimum execution time: 8_080_000 picoseconds.
+		Weight::from_parts(8_385_000, 0)
+			.saturating_add(Weight::from_parts(0, 0))
+	}
+}

pezcumulus/teyrchains/runtimes/people/people-pezkuwichain/src/weights/paritydb_weights.rs

@@ -0,0 +1,63 @@
+// This file is part of Pezcumulus.
+
+// Copyright (C) 2022 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 mod constants {
+	use pezframe_support::{
+		parameter_types,
+		weights::{constants, RuntimeDbWeight},
+	};
+
+	parameter_types! {
+		/// `ParityDB` can be enabled with a feature flag, but is still experimental. These weights
+		/// are available for brave runtime engineers who may want to try this out as default.
+		pub const ParityDbWeight: RuntimeDbWeight = RuntimeDbWeight {
+			read: 8_000 * constants::WEIGHT_REF_TIME_PER_NANOS,
+			write: 50_000 * constants::WEIGHT_REF_TIME_PER_NANOS,
+		};
+	}
+
+	#[cfg(test)]
+	mod test_db_weights {
+		use super::constants::ParityDbWeight as W;
+		use pezframe_support::weights::constants;
+
+		/// Checks that all weights exist and have sane values.
+		// NOTE: If this test fails but you are sure that the generated values are fine,
+		// you can delete it.
+		#[test]
+		fn sane() {
+			// At least 1 µs.
+			assert!(
+				W::get().reads(1).ref_time() >= constants::WEIGHT_REF_TIME_PER_MICROS,
+				"Read weight should be at least 1 µs."
+			);
+			assert!(
+				W::get().writes(1).ref_time() >= constants::WEIGHT_REF_TIME_PER_MICROS,
+				"Write weight should be at least 1 µs."
+			);
+			// At most 1 ms.
+			assert!(
+				W::get().reads(1).ref_time() <= constants::WEIGHT_REF_TIME_PER_MILLIS,
+				"Read weight should be at most 1 ms."
+			);
+			assert!(
+				W::get().writes(1).ref_time() <= constants::WEIGHT_REF_TIME_PER_MILLIS,
+				"Write weight should be at most 1 ms."
+			);
+		}
+	}
+}

pezcumulus/teyrchains/runtimes/people/people-pezkuwichain/src/weights/pezcumulus_pallet_teyrchain_system.rs

@@ -0,0 +1,77 @@
+// 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 `cumulus_pallet_teyrchain_system`
+//!
+//! 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: `afc679a858d4`, 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/people-pezkuwichain-runtime/people_pezkuwichain_runtime.wasm
+// --pallet=cumulus_pallet_teyrchain_system
+// --header=/__w/pezkuwi-sdk/pezkuwi-sdk/pezcumulus/file_header.txt
+// --output=./pezcumulus/teyrchains/runtimes/people/people-pezkuwichain/src/weights
+// --wasm-execution=compiled
+// --steps=50
+// --repeat=20
+// --heap-pages=4096
+// --no-storage-info
+// --no-min-squares
+// --no-median-slopes
+
+#![cfg_attr(rustfmt, rustfmt_skip)]
+#![allow(unused_parens)]
+#![allow(unused_imports)]
+#![allow(missing_docs)]
+
+use pezframe_support::{traits::Get, weights::Weight};
+use core::marker::PhantomData;
+
+/// Weight functions for `cumulus_pallet_teyrchain_system`.
+pub struct WeightInfo<T>(PhantomData<T>);
+impl<T: pezframe_system::Config> cumulus_pallet_teyrchain_system::WeightInfo for WeightInfo<T> {
+	/// Storage: `TeyrchainSystem::LastDmqMqcHead` (r:1 w:1)
+	/// Proof: `TeyrchainSystem::LastDmqMqcHead` (`max_values`: Some(1), `max_size`: None, mode: `Measured`)
+	/// Storage: `MessageQueue::BookStateFor` (r:1 w:1)
+	/// Proof: `MessageQueue::BookStateFor` (`max_values`: None, `max_size`: Some(52), added: 2527, mode: `MaxEncodedLen`)
+	/// Storage: `MessageQueue::ServiceHead` (r:1 w:1)
+	/// Proof: `MessageQueue::ServiceHead` (`max_values`: Some(1), `max_size`: Some(5), added: 500, mode: `MaxEncodedLen`)
+	/// Storage: `TeyrchainSystem::ProcessedDownwardMessages` (r:0 w:1)
+	/// Proof: `TeyrchainSystem::ProcessedDownwardMessages` (`max_values`: Some(1), `max_size`: None, mode: `Measured`)
+	/// Storage: `MessageQueue::Pages` (r:0 w:1000)
+	/// Proof: `MessageQueue::Pages` (`max_values`: None, `max_size`: Some(105521), added: 107996, mode: `MaxEncodedLen`)
+	/// The range of component `n` is `[0, 1000]`.
+	fn enqueue_inbound_downward_messages(n: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `12`
+		//  Estimated: `3517`
+		// Minimum execution time: 2_235_000 picoseconds.
+		Weight::from_parts(2_365_000, 0)
+			.saturating_add(Weight::from_parts(0, 3517))
+			// Standard Error: 66_419
+			.saturating_add(Weight::from_parts(334_432_921, 0).saturating_mul(n.into()))
+			.saturating_add(T::DbWeight::get().reads(3))
+			.saturating_add(T::DbWeight::get().writes(4))
+			.saturating_add(T::DbWeight::get().writes((1_u64).saturating_mul(n.into())))
+	}
+}

pezcumulus/teyrchains/runtimes/people/people-pezkuwichain/src/weights/pezcumulus_pallet_weight_reclaim.rs

@@ -0,0 +1,61 @@
+// 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 `cumulus_pallet_weight_reclaim`
+//!
+//! 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: `afc679a858d4`, 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/people-pezkuwichain-runtime/people_pezkuwichain_runtime.wasm
+// --pallet=cumulus_pallet_weight_reclaim
+// --header=/__w/pezkuwi-sdk/pezkuwi-sdk/pezcumulus/file_header.txt
+// --output=./pezcumulus/teyrchains/runtimes/people/people-pezkuwichain/src/weights
+// --wasm-execution=compiled
+// --steps=50
+// --repeat=20
+// --heap-pages=4096
+// --no-storage-info
+// --no-min-squares
+// --no-median-slopes
+
+#![cfg_attr(rustfmt, rustfmt_skip)]
+#![allow(unused_parens)]
+#![allow(unused_imports)]
+#![allow(missing_docs)]
+
+use pezframe_support::{traits::Get, weights::Weight};
+use core::marker::PhantomData;
+
+/// Weight functions for `cumulus_pallet_weight_reclaim`.
+pub struct WeightInfo<T>(PhantomData<T>);
+impl<T: pezframe_system::Config> cumulus_pallet_weight_reclaim::WeightInfo for WeightInfo<T> {
+	fn storage_weight_reclaim() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0`
+		//  Estimated: `0`
+		// Minimum execution time: 3_983_000 picoseconds.
+		Weight::from_parts(4_164_000, 0)
+			.saturating_add(Weight::from_parts(0, 0))
+	}
+}

pezcumulus/teyrchains/runtimes/people/people-pezkuwichain/src/weights/pezcumulus_pallet_xcmp_queue.rs

@@ -0,0 +1,258 @@
+// 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 `cumulus_pallet_xcmp_queue`
+//!
+//! THIS FILE WAS AUTO-GENERATED USING THE BIZINIKIWI BENCHMARK CLI VERSION 32.0.0
+//! DATE: 2025-09-04, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]`
+//! WORST CASE MAP SIZE: `1000000`
+//! HOSTNAME: `4e9548205c14`, 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/people-pezkuwichain-runtime/people_pezkuwichain_runtime.wasm
+// --pallet=cumulus_pallet_xcmp_queue
+// --header=/__w/pezkuwi-sdk/pezkuwi-sdk/pezcumulus/file_header.txt
+// --output=./pezcumulus/teyrchains/runtimes/people/people-pezkuwichain/src/weights
+// --wasm-execution=compiled
+// --steps=50
+// --repeat=20
+// --heap-pages=4096
+// --no-storage-info
+// --no-min-squares
+// --no-median-slopes
+
+#![cfg_attr(rustfmt, rustfmt_skip)]
+#![allow(unused_parens)]
+#![allow(unused_imports)]
+#![allow(missing_docs)]
+
+use pezframe_support::{traits::Get, weights::Weight};
+use core::marker::PhantomData;
+
+/// Weight functions for `cumulus_pallet_xcmp_queue`.
+pub struct WeightInfo<T>(PhantomData<T>);
+impl<T: pezframe_system::Config> cumulus_pallet_xcmp_queue::WeightInfo for WeightInfo<T> {
+	/// Storage: `XcmpQueue::QueueConfig` (r:1 w:1)
+	/// Proof: `XcmpQueue::QueueConfig` (`max_values`: Some(1), `max_size`: Some(12), added: 507, mode: `MaxEncodedLen`)
+	fn set_config_with_u32() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `76`
+		//  Estimated: `1497`
+		// Minimum execution time: 5_101_000 picoseconds.
+		Weight::from_parts(5_445_000, 0)
+			.saturating_add(Weight::from_parts(0, 1497))
+			.saturating_add(T::DbWeight::get().reads(1))
+			.saturating_add(T::DbWeight::get().writes(1))
+	}
+	/// Storage: `XcmpQueue::QueueConfig` (r:1 w:0)
+	/// Proof: `XcmpQueue::QueueConfig` (`max_values`: Some(1), `max_size`: Some(12), added: 507, mode: `MaxEncodedLen`)
+	/// Storage: `MessageQueue::BookStateFor` (r:1 w:1)
+	/// Proof: `MessageQueue::BookStateFor` (`max_values`: None, `max_size`: Some(52), added: 2527, mode: `MaxEncodedLen`)
+	/// Storage: `MessageQueue::ServiceHead` (r:1 w:1)
+	/// Proof: `MessageQueue::ServiceHead` (`max_values`: Some(1), `max_size`: Some(5), added: 500, mode: `MaxEncodedLen`)
+	/// Storage: `XcmpQueue::InboundXcmpSuspended` (r:1 w:0)
+	/// Proof: `XcmpQueue::InboundXcmpSuspended` (`max_values`: Some(1), `max_size`: Some(4002), added: 4497, mode: `MaxEncodedLen`)
+	/// Storage: `MessageQueue::Pages` (r:0 w:1)
+	/// Proof: `MessageQueue::Pages` (`max_values`: None, `max_size`: Some(105521), added: 107996, mode: `MaxEncodedLen`)
+	/// The range of component `n` is `[0, 105467]`.
+	fn enqueue_n_bytes_xcmp_message(n: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `82`
+		//  Estimated: `5487`
+		// Minimum execution time: 13_691_000 picoseconds.
+		Weight::from_parts(9_579_858, 0)
+			.saturating_add(Weight::from_parts(0, 5487))
+			// Standard Error: 7
+			.saturating_add(Weight::from_parts(968, 0).saturating_mul(n.into()))
+			.saturating_add(T::DbWeight::get().reads(4))
+			.saturating_add(T::DbWeight::get().writes(3))
+	}
+	/// Storage: `XcmpQueue::QueueConfig` (r:1 w:0)
+	/// Proof: `XcmpQueue::QueueConfig` (`max_values`: Some(1), `max_size`: Some(12), added: 507, mode: `MaxEncodedLen`)
+	/// Storage: `MessageQueue::BookStateFor` (r:1 w:1)
+	/// Proof: `MessageQueue::BookStateFor` (`max_values`: None, `max_size`: Some(52), added: 2527, mode: `MaxEncodedLen`)
+	/// Storage: `MessageQueue::ServiceHead` (r:1 w:1)
+	/// Proof: `MessageQueue::ServiceHead` (`max_values`: Some(1), `max_size`: Some(5), added: 500, mode: `MaxEncodedLen`)
+	/// Storage: `XcmpQueue::InboundXcmpSuspended` (r:1 w:0)
+	/// Proof: `XcmpQueue::InboundXcmpSuspended` (`max_values`: Some(1), `max_size`: Some(4002), added: 4497, mode: `MaxEncodedLen`)
+	/// Storage: `MessageQueue::Pages` (r:0 w:1)
+	/// Proof: `MessageQueue::Pages` (`max_values`: None, `max_size`: Some(105521), added: 107996, mode: `MaxEncodedLen`)
+	/// The range of component `n` is `[0, 1000]`.
+	fn enqueue_n_empty_xcmp_messages(n: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `82`
+		//  Estimated: `5487`
+		// Minimum execution time: 11_450_000 picoseconds.
+		Weight::from_parts(16_374_477, 0)
+			.saturating_add(Weight::from_parts(0, 5487))
+			// Standard Error: 185
+			.saturating_add(Weight::from_parts(141_346, 0).saturating_mul(n.into()))
+			.saturating_add(T::DbWeight::get().reads(4))
+			.saturating_add(T::DbWeight::get().writes(3))
+	}
+	/// Storage: `XcmpQueue::QueueConfig` (r:1 w:0)
+	/// Proof: `XcmpQueue::QueueConfig` (`max_values`: Some(1), `max_size`: Some(12), added: 507, mode: `Measured`)
+	/// Storage: `MessageQueue::BookStateFor` (r:1 w:1)
+	/// Proof: `MessageQueue::BookStateFor` (`max_values`: None, `max_size`: Some(52), added: 2527, mode: `Measured`)
+	/// Storage: `MessageQueue::Pages` (r:1 w:1)
+	/// Proof: `MessageQueue::Pages` (`max_values`: None, `max_size`: Some(105521), added: 107996, mode: `Measured`)
+	/// Storage: `XcmpQueue::InboundXcmpSuspended` (r:1 w:0)
+	/// Proof: `XcmpQueue::InboundXcmpSuspended` (`max_values`: Some(1), `max_size`: Some(4002), added: 4497, mode: `Measured`)
+	/// The range of component `n` is `[0, 105457]`.
+	fn enqueue_empty_xcmp_message_at(n: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `264 + n * (1 ±0)`
+		//  Estimated: `3727 + n * (1 ±0)`
+		// Minimum execution time: 20_584_000 picoseconds.
+		Weight::from_parts(12_592_313, 0)
+			.saturating_add(Weight::from_parts(0, 3727))
+			// Standard Error: 11
+			.saturating_add(Weight::from_parts(2_031, 0).saturating_mul(n.into()))
+			.saturating_add(T::DbWeight::get().reads(4))
+			.saturating_add(T::DbWeight::get().writes(2))
+			.saturating_add(Weight::from_parts(0, 1).saturating_mul(n.into()))
+	}
+	/// Storage: `XcmpQueue::QueueConfig` (r:1 w:0)
+	/// Proof: `XcmpQueue::QueueConfig` (`max_values`: Some(1), `max_size`: Some(12), added: 507, mode: `MaxEncodedLen`)
+	/// Storage: `MessageQueue::BookStateFor` (r:1 w:1)
+	/// Proof: `MessageQueue::BookStateFor` (`max_values`: None, `max_size`: Some(52), added: 2527, mode: `MaxEncodedLen`)
+	/// Storage: `MessageQueue::ServiceHead` (r:1 w:1)
+	/// Proof: `MessageQueue::ServiceHead` (`max_values`: Some(1), `max_size`: Some(5), added: 500, mode: `MaxEncodedLen`)
+	/// Storage: `XcmpQueue::InboundXcmpSuspended` (r:1 w:0)
+	/// Proof: `XcmpQueue::InboundXcmpSuspended` (`max_values`: Some(1), `max_size`: Some(4002), added: 4497, mode: `MaxEncodedLen`)
+	/// Storage: `MessageQueue::Pages` (r:0 w:100)
+	/// Proof: `MessageQueue::Pages` (`max_values`: None, `max_size`: Some(105521), added: 107996, mode: `MaxEncodedLen`)
+	/// The range of component `n` is `[0, 100]`.
+	fn enqueue_n_full_pages(n: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `117`
+		//  Estimated: `5487`
+		// Minimum execution time: 13_072_000 picoseconds.
+		Weight::from_parts(13_407_000, 0)
+			.saturating_add(Weight::from_parts(0, 5487))
+			// Standard Error: 48_045
+			.saturating_add(Weight::from_parts(92_778_071, 0).saturating_mul(n.into()))
+			.saturating_add(T::DbWeight::get().reads(4))
+			.saturating_add(T::DbWeight::get().writes(2))
+			.saturating_add(T::DbWeight::get().writes((1_u64).saturating_mul(n.into())))
+	}
+	/// Storage: `XcmpQueue::QueueConfig` (r:1 w:0)
+	/// Proof: `XcmpQueue::QueueConfig` (`max_values`: Some(1), `max_size`: Some(12), added: 507, mode: `Measured`)
+	/// Storage: `MessageQueue::BookStateFor` (r:1 w:1)
+	/// Proof: `MessageQueue::BookStateFor` (`max_values`: None, `max_size`: Some(52), added: 2527, mode: `Measured`)
+	/// Storage: `MessageQueue::Pages` (r:1 w:1)
+	/// Proof: `MessageQueue::Pages` (`max_values`: None, `max_size`: Some(105521), added: 107996, mode: `Measured`)
+	/// Storage: `XcmpQueue::InboundXcmpSuspended` (r:1 w:0)
+	/// Proof: `XcmpQueue::InboundXcmpSuspended` (`max_values`: Some(1), `max_size`: Some(4002), added: 4497, mode: `Measured`)
+	fn enqueue_1000_small_xcmp_messages() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `52997`
+		//  Estimated: `56462`
+		// Minimum execution time: 267_839_000 picoseconds.
+		Weight::from_parts(288_522_000, 0)
+			.saturating_add(Weight::from_parts(0, 56462))
+			.saturating_add(T::DbWeight::get().reads(4))
+			.saturating_add(T::DbWeight::get().writes(2))
+	}
+	/// Storage: `XcmpQueue::OutboundXcmpStatus` (r:1 w:1)
+	/// Proof: `XcmpQueue::OutboundXcmpStatus` (`max_values`: Some(1), `max_size`: Some(1282), added: 1777, mode: `MaxEncodedLen`)
+	fn suspend_channel() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `76`
+		//  Estimated: `2767`
+		// Minimum execution time: 3_273_000 picoseconds.
+		Weight::from_parts(3_456_000, 0)
+			.saturating_add(Weight::from_parts(0, 2767))
+			.saturating_add(T::DbWeight::get().reads(1))
+			.saturating_add(T::DbWeight::get().writes(1))
+	}
+	/// Storage: `XcmpQueue::OutboundXcmpStatus` (r:1 w:1)
+	/// Proof: `XcmpQueue::OutboundXcmpStatus` (`max_values`: Some(1), `max_size`: Some(1282), added: 1777, mode: `MaxEncodedLen`)
+	fn resume_channel() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `111`
+		//  Estimated: `2767`
+		// Minimum execution time: 4_640_000 picoseconds.
+		Weight::from_parts(4_888_000, 0)
+			.saturating_add(Weight::from_parts(0, 2767))
+			.saturating_add(T::DbWeight::get().reads(1))
+			.saturating_add(T::DbWeight::get().writes(1))
+	}
+	/// The range of component `n` is `[0, 92]`.
+	fn take_first_concatenated_xcm(n: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0`
+		//  Estimated: `0`
+		// Minimum execution time: 2_026_000 picoseconds.
+		Weight::from_parts(2_467_443, 0)
+			.saturating_add(Weight::from_parts(0, 0))
+			// Standard Error: 218
+			.saturating_add(Weight::from_parts(17_664, 0).saturating_mul(n.into()))
+	}
+	/// Storage: UNKNOWN KEY `0x7b3237373ffdfeb1cab4222e3b520d6b345d8e88afa015075c945637c07e8f20` (r:1 w:1)
+	/// Proof: UNKNOWN KEY `0x7b3237373ffdfeb1cab4222e3b520d6b345d8e88afa015075c945637c07e8f20` (r:1 w:1)
+	/// Storage: UNKNOWN KEY `0x7b3237373ffdfeb1cab4222e3b520d6bedc49980ba3aa32b0a189290fd036649` (r:1 w:1)
+	/// Proof: UNKNOWN KEY `0x7b3237373ffdfeb1cab4222e3b520d6bedc49980ba3aa32b0a189290fd036649` (r:1 w:1)
+	/// Storage: `MessageQueue::BookStateFor` (r:1 w:1)
+	/// Proof: `MessageQueue::BookStateFor` (`max_values`: None, `max_size`: Some(52), added: 2527, mode: `MaxEncodedLen`)
+	/// Storage: `MessageQueue::ServiceHead` (r:1 w:1)
+	/// Proof: `MessageQueue::ServiceHead` (`max_values`: Some(1), `max_size`: Some(5), added: 500, mode: `MaxEncodedLen`)
+	/// Storage: `XcmpQueue::QueueConfig` (r:1 w:0)
+	/// Proof: `XcmpQueue::QueueConfig` (`max_values`: Some(1), `max_size`: Some(12), added: 507, mode: `MaxEncodedLen`)
+	/// Storage: `XcmpQueue::InboundXcmpSuspended` (r:1 w:0)
+	/// Proof: `XcmpQueue::InboundXcmpSuspended` (`max_values`: Some(1), `max_size`: Some(4002), added: 4497, mode: `MaxEncodedLen`)
+	/// Storage: `MessageQueue::Pages` (r:0 w:1)
+	/// Proof: `MessageQueue::Pages` (`max_values`: None, `max_size`: Some(105521), added: 107996, mode: `MaxEncodedLen`)
+	fn on_idle_good_msg() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `105647`
+		//  Estimated: `109112`
+		// Minimum execution time: 175_346_000 picoseconds.
+		Weight::from_parts(178_900_000, 0)
+			.saturating_add(Weight::from_parts(0, 109112))
+			.saturating_add(T::DbWeight::get().reads(6))
+			.saturating_add(T::DbWeight::get().writes(5))
+	}
+	/// Storage: UNKNOWN KEY `0x7b3237373ffdfeb1cab4222e3b520d6b345d8e88afa015075c945637c07e8f20` (r:1 w:1)
+	/// Proof: UNKNOWN KEY `0x7b3237373ffdfeb1cab4222e3b520d6b345d8e88afa015075c945637c07e8f20` (r:1 w:1)
+	/// Storage: UNKNOWN KEY `0x7b3237373ffdfeb1cab4222e3b520d6bedc49980ba3aa32b0a189290fd036649` (r:1 w:1)
+	/// Proof: UNKNOWN KEY `0x7b3237373ffdfeb1cab4222e3b520d6bedc49980ba3aa32b0a189290fd036649` (r:1 w:1)
+	/// Storage: `MessageQueue::BookStateFor` (r:1 w:1)
+	/// Proof: `MessageQueue::BookStateFor` (`max_values`: None, `max_size`: Some(52), added: 2527, mode: `MaxEncodedLen`)
+	/// Storage: `MessageQueue::ServiceHead` (r:1 w:1)
+	/// Proof: `MessageQueue::ServiceHead` (`max_values`: Some(1), `max_size`: Some(5), added: 500, mode: `MaxEncodedLen`)
+	/// Storage: `XcmpQueue::QueueConfig` (r:1 w:0)
+	/// Proof: `XcmpQueue::QueueConfig` (`max_values`: Some(1), `max_size`: Some(12), added: 507, mode: `MaxEncodedLen`)
+	/// Storage: `XcmpQueue::InboundXcmpSuspended` (r:1 w:0)
+	/// Proof: `XcmpQueue::InboundXcmpSuspended` (`max_values`: Some(1), `max_size`: Some(4002), added: 4497, mode: `MaxEncodedLen`)
+	/// Storage: `MessageQueue::Pages` (r:0 w:1)
+	/// Proof: `MessageQueue::Pages` (`max_values`: None, `max_size`: Some(105521), added: 107996, mode: `MaxEncodedLen`)
+	fn on_idle_large_msg() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `65716`
+		//  Estimated: `69181`
+		// Minimum execution time: 117_370_000 picoseconds.
+		Weight::from_parts(119_465_000, 0)
+			.saturating_add(Weight::from_parts(0, 69181))
+			.saturating_add(T::DbWeight::get().reads(6))
+			.saturating_add(T::DbWeight::get().writes(5))
+	}
+}

pezcumulus/teyrchains/runtimes/people/people-pezkuwichain/src/weights/pezkuwi_runtime_common_identity_migrator.rs

@@ -0,0 +1,94 @@
+// 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 `pezkuwi_runtime_common::identity_migrator`
+//!
+//! 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: `afc679a858d4`, 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/people-pezkuwichain-runtime/people_pezkuwichain_runtime.wasm
+// --pallet=pezkuwi_runtime_common::identity_migrator
+// --header=/__w/pezkuwi-sdk/pezkuwi-sdk/pezcumulus/file_header.txt
+// --output=./pezcumulus/teyrchains/runtimes/people/people-pezkuwichain/src/weights
+// --wasm-execution=compiled
+// --steps=50
+// --repeat=20
+// --heap-pages=4096
+// --no-storage-info
+// --no-min-squares
+// --no-median-slopes
+
+#![cfg_attr(rustfmt, rustfmt_skip)]
+#![allow(unused_parens)]
+#![allow(unused_imports)]
+#![allow(missing_docs)]
+
+use pezframe_support::{traits::Get, weights::Weight};
+use core::marker::PhantomData;
+
+/// Weight functions for `pezkuwi_runtime_common::identity_migrator`.
+pub struct WeightInfo<T>(PhantomData<T>);
+impl<T: pezframe_system::Config> pezkuwi_runtime_common::identity_migrator::WeightInfo for WeightInfo<T> {
+	/// Storage: `Identity::IdentityOf` (r:1 w:1)
+	/// Proof: `Identity::IdentityOf` (`max_values`: None, `max_size`: Some(804), added: 3279, mode: `MaxEncodedLen`)
+	/// Storage: `Identity::SubsOf` (r:1 w:1)
+	/// Proof: `Identity::SubsOf` (`max_values`: None, `max_size`: Some(3258), added: 5733, mode: `MaxEncodedLen`)
+	/// Storage: `System::Account` (r:1 w:1)
+	/// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `MaxEncodedLen`)
+	/// Storage: `Identity::SuperOf` (r:0 w:100)
+	/// Proof: `Identity::SuperOf` (`max_values`: None, `max_size`: Some(114), added: 2589, mode: `MaxEncodedLen`)
+	/// The range of component `r` is `[0, 20]`.
+	/// The range of component `s` is `[0, 100]`.
+	fn reap_identity(r: u32, s: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `673 + r * (5 ±0) + s * (32 ±0)`
+		//  Estimated: `6723`
+		// Minimum execution time: 35_063_000 picoseconds.
+		Weight::from_parts(34_643_325, 0)
+			.saturating_add(Weight::from_parts(0, 6723))
+			// Standard Error: 15_530
+			.saturating_add(Weight::from_parts(259_757, 0).saturating_mul(r.into()))
+			// Standard Error: 3_181
+			.saturating_add(Weight::from_parts(1_506_816, 0).saturating_mul(s.into()))
+			.saturating_add(T::DbWeight::get().reads(3))
+			.saturating_add(T::DbWeight::get().writes(3))
+			.saturating_add(T::DbWeight::get().writes((1_u64).saturating_mul(s.into())))
+	}
+	/// Storage: `Identity::IdentityOf` (r:1 w:1)
+	/// Proof: `Identity::IdentityOf` (`max_values`: None, `max_size`: Some(804), added: 3279, mode: `MaxEncodedLen`)
+	/// Storage: `System::Account` (r:1 w:1)
+	/// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `MaxEncodedLen`)
+	/// Storage: `Identity::SubsOf` (r:1 w:1)
+	/// Proof: `Identity::SubsOf` (`max_values`: None, `max_size`: Some(3258), added: 5733, mode: `MaxEncodedLen`)
+	fn poke_deposit() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `634`
+		//  Estimated: `6723`
+		// Minimum execution time: 47_179_000 picoseconds.
+		Weight::from_parts(48_906_000, 0)
+			.saturating_add(Weight::from_parts(0, 6723))
+			.saturating_add(T::DbWeight::get().reads(3))
+			.saturating_add(T::DbWeight::get().writes(3))
+	}
+}

pezcumulus/teyrchains/runtimes/people/people-pezkuwichain/src/weights/rocksdb_weights.rs

@@ -0,0 +1,63 @@
+// This file is part of Pezcumulus.
+
+// Copyright (C) 2022 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 mod constants {
+	use pezframe_support::{
+		parameter_types,
+		weights::{constants, RuntimeDbWeight},
+	};
+
+	parameter_types! {
+		/// By default, Bizinikiwi uses `RocksDB`, so this will be the weight used throughout
+		/// the runtime.
+		pub const RocksDbWeight: RuntimeDbWeight = RuntimeDbWeight {
+			read: 25_000 * constants::WEIGHT_REF_TIME_PER_NANOS,
+			write: 100_000 * constants::WEIGHT_REF_TIME_PER_NANOS,
+		};
+	}
+
+	#[cfg(test)]
+	mod test_db_weights {
+		use super::constants::RocksDbWeight as W;
+		use pezframe_support::weights::constants;
+
+		/// Checks that all weights exist and have sane values.
+		// NOTE: If this test fails but you are sure that the generated values are fine,
+		// you can delete it.
+		#[test]
+		fn sane() {
+			// At least 1 µs.
+			assert!(
+				W::get().reads(1).ref_time() >= constants::WEIGHT_REF_TIME_PER_MICROS,
+				"Read weight should be at least 1 µs."
+			);
+			assert!(
+				W::get().writes(1).ref_time() >= constants::WEIGHT_REF_TIME_PER_MICROS,
+				"Write weight should be at least 1 µs."
+			);
+			// At most 1 ms.
+			assert!(
+				W::get().reads(1).ref_time() <= constants::WEIGHT_REF_TIME_PER_MILLIS,
+				"Read weight should be at most 1 ms."
+			);
+			assert!(
+				W::get().writes(1).ref_time() <= constants::WEIGHT_REF_TIME_PER_MILLIS,
+				"Write weight should be at most 1 ms."
+			);
+		}
+	}
+}

pezcumulus/teyrchains/runtimes/people/people-pezkuwichain/src/weights/xcm/mod.rs

@@ -0,0 +1,272 @@
+// 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.
+
+mod pezpallet_xcm_benchmarks_fungible;
+mod pezpallet_xcm_benchmarks_generic;
+
+use crate::{xcm_config::MaxAssetsIntoHolding, Runtime};
+use alloc::vec::Vec;
+use pezframe_support::weights::Weight;
+use pezpallet_xcm_benchmarks_fungible::WeightInfo as XcmFungibleWeight;
+use pezpallet_xcm_benchmarks_generic::WeightInfo as XcmGeneric;
+use pezsp_runtime::BoundedVec;
+use xcm::{
+	latest::{prelude::*, AssetTransferFilter},
+	DoubleEncoded,
+};
+
+trait WeighAssets {
+	fn weigh_assets(&self, weight: Weight) -> Weight;
+}
+
+const MAX_ASSETS: u64 = 100;
+
+impl WeighAssets for AssetFilter {
+	fn weigh_assets(&self, weight: Weight) -> Weight {
+		match self {
+			Self::Definite(assets) => weight.saturating_mul(assets.inner().iter().count() as u64),
+			Self::Wild(asset) => match asset {
+				All => weight.saturating_mul(MAX_ASSETS),
+				AllOf { fun, .. } => match fun {
+					WildFungibility::Fungible => weight,
+					// Magic number 2 has to do with the fact that we could have up to 2 times
+					// MaxAssetsIntoHolding in the worst-case scenario.
+					WildFungibility::NonFungible =>
+						weight.saturating_mul((MaxAssetsIntoHolding::get() * 2) as u64),
+				},
+				AllCounted(count) => weight.saturating_mul(MAX_ASSETS.min(*count as u64)),
+				AllOfCounted { count, .. } => weight.saturating_mul(MAX_ASSETS.min(*count as u64)),
+			},
+		}
+	}
+}
+
+impl WeighAssets for Assets {
+	fn weigh_assets(&self, weight: Weight) -> Weight {
+		weight.saturating_mul(self.inner().iter().count() as u64)
+	}
+}
+
+pub struct PeoplePezkuwichainXcmWeight<Call>(core::marker::PhantomData<Call>);
+impl<Call> XcmWeightInfo<Call> for PeoplePezkuwichainXcmWeight<Call> {
+	fn withdraw_asset(assets: &Assets) -> Weight {
+		assets.weigh_assets(XcmFungibleWeight::<Runtime>::withdraw_asset())
+	}
+	fn reserve_asset_deposited(assets: &Assets) -> Weight {
+		assets.weigh_assets(XcmFungibleWeight::<Runtime>::reserve_asset_deposited())
+	}
+	fn receive_teleported_asset(assets: &Assets) -> Weight {
+		assets.weigh_assets(XcmFungibleWeight::<Runtime>::receive_teleported_asset())
+	}
+	fn query_response(
+		_query_id: &u64,
+		_response: &Response,
+		_max_weight: &Weight,
+		_querier: &Option<Location>,
+	) -> Weight {
+		XcmGeneric::<Runtime>::query_response()
+	}
+	fn transfer_asset(assets: &Assets, _dest: &Location) -> Weight {
+		assets.weigh_assets(XcmFungibleWeight::<Runtime>::transfer_asset())
+	}
+	fn transfer_reserve_asset(assets: &Assets, _dest: &Location, _xcm: &Xcm<()>) -> Weight {
+		assets.weigh_assets(XcmFungibleWeight::<Runtime>::transfer_reserve_asset())
+	}
+	fn transact(
+		_origin_type: &OriginKind,
+		_fallback_max_weight: &Option<Weight>,
+		_call: &DoubleEncoded<Call>,
+	) -> Weight {
+		XcmGeneric::<Runtime>::transact()
+	}
+	fn hrmp_new_channel_open_request(
+		_sender: &u32,
+		_max_message_size: &u32,
+		_max_capacity: &u32,
+	) -> Weight {
+		// XCM Executor does not currently support HRMP channel operations
+		Weight::MAX
+	}
+	fn hrmp_channel_accepted(_recipient: &u32) -> Weight {
+		// XCM Executor does not currently support HRMP channel operations
+		Weight::MAX
+	}
+	fn hrmp_channel_closing(_initiator: &u32, _sender: &u32, _recipient: &u32) -> Weight {
+		// XCM Executor does not currently support HRMP channel operations
+		Weight::MAX
+	}
+	fn clear_origin() -> Weight {
+		XcmGeneric::<Runtime>::clear_origin()
+	}
+	fn descend_origin(_who: &InteriorLocation) -> Weight {
+		XcmGeneric::<Runtime>::descend_origin()
+	}
+	fn report_error(_query_response_info: &QueryResponseInfo) -> Weight {
+		XcmGeneric::<Runtime>::report_error()
+	}
+	fn deposit_asset(assets: &AssetFilter, _dest: &Location) -> Weight {
+		assets.weigh_assets(XcmFungibleWeight::<Runtime>::deposit_asset())
+	}
+	fn deposit_reserve_asset(assets: &AssetFilter, _dest: &Location, _xcm: &Xcm<()>) -> Weight {
+		assets.weigh_assets(XcmFungibleWeight::<Runtime>::deposit_reserve_asset())
+	}
+	fn exchange_asset(_give: &AssetFilter, _receive: &Assets, _maximal: &bool) -> Weight {
+		Weight::MAX
+	}
+	fn initiate_reserve_withdraw(
+		assets: &AssetFilter,
+		_reserve: &Location,
+		_xcm: &Xcm<()>,
+	) -> Weight {
+		assets.weigh_assets(XcmFungibleWeight::<Runtime>::initiate_reserve_withdraw())
+	}
+	fn initiate_teleport(assets: &AssetFilter, _dest: &Location, _xcm: &Xcm<()>) -> Weight {
+		assets.weigh_assets(XcmFungibleWeight::<Runtime>::initiate_teleport())
+	}
+	fn initiate_transfer(
+		_dest: &Location,
+		remote_fees: &Option<AssetTransferFilter>,
+		_preserve_origin: &bool,
+		assets: &BoundedVec<AssetTransferFilter, MaxAssetTransferFilters>,
+		_xcm: &Xcm<()>,
+	) -> Weight {
+		let mut weight = if let Some(remote_fees) = remote_fees {
+			let fees = remote_fees.inner();
+			fees.weigh_assets(XcmFungibleWeight::<Runtime>::initiate_transfer())
+		} else {
+			Weight::zero()
+		};
+		for asset_filter in assets {
+			let assets = asset_filter.inner();
+			let extra = assets.weigh_assets(XcmFungibleWeight::<Runtime>::initiate_transfer());
+			weight = weight.saturating_add(extra);
+		}
+		weight
+	}
+	fn report_holding(_response_info: &QueryResponseInfo, _assets: &AssetFilter) -> Weight {
+		XcmGeneric::<Runtime>::report_holding()
+	}
+	fn buy_execution(_fees: &Asset, _weight_limit: &WeightLimit) -> Weight {
+		XcmGeneric::<Runtime>::buy_execution()
+	}
+	fn pay_fees(_asset: &Asset) -> Weight {
+		XcmGeneric::<Runtime>::pay_fees()
+	}
+	fn refund_surplus() -> Weight {
+		XcmGeneric::<Runtime>::refund_surplus()
+	}
+	fn set_error_handler(_xcm: &Xcm<Call>) -> Weight {
+		XcmGeneric::<Runtime>::set_error_handler()
+	}
+	fn set_appendix(_xcm: &Xcm<Call>) -> Weight {
+		XcmGeneric::<Runtime>::set_appendix()
+	}
+	fn clear_error() -> Weight {
+		XcmGeneric::<Runtime>::clear_error()
+	}
+	fn claim_asset(_assets: &Assets, _ticket: &Location) -> Weight {
+		XcmGeneric::<Runtime>::claim_asset()
+	}
+	fn trap(_code: &u64) -> Weight {
+		XcmGeneric::<Runtime>::trap()
+	}
+	fn subscribe_version(_query_id: &QueryId, _max_response_weight: &Weight) -> Weight {
+		XcmGeneric::<Runtime>::subscribe_version()
+	}
+	fn unsubscribe_version() -> Weight {
+		XcmGeneric::<Runtime>::unsubscribe_version()
+	}
+	fn burn_asset(assets: &Assets) -> Weight {
+		assets.weigh_assets(XcmGeneric::<Runtime>::burn_asset())
+	}
+	fn expect_asset(assets: &Assets) -> Weight {
+		assets.weigh_assets(XcmGeneric::<Runtime>::expect_asset())
+	}
+	fn expect_origin(_origin: &Option<Location>) -> Weight {
+		XcmGeneric::<Runtime>::expect_origin()
+	}
+	fn expect_error(_error: &Option<(u32, XcmError)>) -> Weight {
+		XcmGeneric::<Runtime>::expect_error()
+	}
+	fn expect_transact_status(_transact_status: &MaybeErrorCode) -> Weight {
+		XcmGeneric::<Runtime>::expect_transact_status()
+	}
+	fn query_pallet(_module_name: &Vec<u8>, _response_info: &QueryResponseInfo) -> Weight {
+		XcmGeneric::<Runtime>::query_pallet()
+	}
+	fn expect_pallet(
+		_index: &u32,
+		_name: &Vec<u8>,
+		_module_name: &Vec<u8>,
+		_crate_major: &u32,
+		_min_crate_minor: &u32,
+	) -> Weight {
+		XcmGeneric::<Runtime>::expect_pallet()
+	}
+	fn report_transact_status(_response_info: &QueryResponseInfo) -> Weight {
+		XcmGeneric::<Runtime>::report_transact_status()
+	}
+	fn clear_transact_status() -> Weight {
+		XcmGeneric::<Runtime>::clear_transact_status()
+	}
+	fn universal_origin(_: &Junction) -> Weight {
+		Weight::MAX
+	}
+	fn export_message(_: &NetworkId, _: &Junctions, _: &Xcm<()>) -> Weight {
+		Weight::MAX
+	}
+	fn lock_asset(_: &Asset, _: &Location) -> Weight {
+		Weight::MAX
+	}
+	fn unlock_asset(_: &Asset, _: &Location) -> Weight {
+		Weight::MAX
+	}
+	fn note_unlockable(_: &Asset, _: &Location) -> Weight {
+		Weight::MAX
+	}
+	fn request_unlock(_: &Asset, _: &Location) -> Weight {
+		Weight::MAX
+	}
+	fn set_fees_mode(_: &bool) -> Weight {
+		XcmGeneric::<Runtime>::set_fees_mode()
+	}
+	fn set_topic(_topic: &[u8; 32]) -> Weight {
+		XcmGeneric::<Runtime>::set_topic()
+	}
+	fn clear_topic() -> Weight {
+		XcmGeneric::<Runtime>::clear_topic()
+	}
+	fn alias_origin(_: &Location) -> Weight {
+		// XCM Executor does not currently support alias origin operations
+		Weight::MAX
+	}
+	fn unpaid_execution(_: &WeightLimit, _: &Option<Location>) -> Weight {
+		XcmGeneric::<Runtime>::unpaid_execution()
+	}
+	fn set_hints(hints: &BoundedVec<Hint, HintNumVariants>) -> Weight {
+		let mut weight = Weight::zero();
+		for hint in hints {
+			match hint {
+				AssetClaimer { .. } => {
+					weight = weight.saturating_add(XcmGeneric::<Runtime>::asset_claimer());
+				},
+			}
+		}
+		weight
+	}
+	fn execute_with_origin(_: &Option<InteriorLocation>, _: &Xcm<Call>) -> Weight {
+		XcmGeneric::<Runtime>::execute_with_origin()
+	}
+}

pezcumulus/teyrchains/runtimes/people/people-pezkuwichain/src/weights/xcm/pallet_xcm_benchmarks_fungible.rs

@@ -0,0 +1,215 @@
+// 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_xcm_benchmarks::fungible`
+//!
+//! THIS FILE WAS AUTO-GENERATED USING THE BIZINIKIWI BENCHMARK CLI VERSION 32.0.0
+//! DATE: 2025-07-30, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]`
+//! WORST CASE MAP SIZE: `1000000`
+//! HOSTNAME: `a49f76527979`, 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/people-pezkuwichain-runtime/people_pezkuwichain_runtime.wasm
+// --pallet=pezpallet_xcm_benchmarks::fungible
+// --header=/__w/pezkuwi-sdk/pezkuwi-sdk/pezcumulus/file_header.txt
+// --output=./pezcumulus/teyrchains/runtimes/people/people-pezkuwichain/src/weights/xcm
+// --wasm-execution=compiled
+// --steps=50
+// --repeat=20
+// --heap-pages=4096
+// --template=pezcumulus/templates/xcm-bench-template.hbs
+// --no-storage-info
+// --no-min-squares
+// --no-median-slopes
+
+#![cfg_attr(rustfmt, rustfmt_skip)]
+#![allow(unused_parens)]
+#![allow(unused_imports)]
+
+use pezframe_support::{traits::Get, weights::Weight};
+use core::marker::PhantomData;
+
+/// Weights for `pezpallet_xcm_benchmarks::fungible`.
+pub struct WeightInfo<T>(PhantomData<T>);
+impl<T: pezframe_system::Config> WeightInfo<T> {
+	// Storage: `System::Account` (r:1 w:1)
+	// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `MaxEncodedLen`)
+	pub fn withdraw_asset() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `101`
+		//  Estimated: `3593`
+		// Minimum execution time: 30_722_000 picoseconds.
+		Weight::from_parts(31_547_000, 3593)
+			.saturating_add(T::DbWeight::get().reads(1))
+			.saturating_add(T::DbWeight::get().writes(1))
+	}
+	// Storage: `System::Account` (r:2 w:2)
+	// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `MaxEncodedLen`)
+	pub fn transfer_asset() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `101`
+		//  Estimated: `6196`
+		// Minimum execution time: 41_885_000 picoseconds.
+		Weight::from_parts(42_845_000, 6196)
+			.saturating_add(T::DbWeight::get().reads(2))
+			.saturating_add(T::DbWeight::get().writes(2))
+	}
+	// Storage: `System::Account` (r:3 w:3)
+	// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `MaxEncodedLen`)
+	// Storage: `TeyrchainInfo::TeyrchainId` (r:1 w:0)
+	// Proof: `TeyrchainInfo::TeyrchainId` (`max_values`: Some(1), `max_size`: Some(4), added: 499, mode: `MaxEncodedLen`)
+	// Storage: `XcmpQueue::DeliveryFeeFactor` (r:1 w:0)
+	// Proof: `XcmpQueue::DeliveryFeeFactor` (`max_values`: None, `max_size`: Some(28), added: 2503, mode: `MaxEncodedLen`)
+	// Storage: `PezkuwiXcm::SupportedVersion` (r:1 w:0)
+	// Proof: `PezkuwiXcm::SupportedVersion` (`max_values`: None, `max_size`: None, mode: `Measured`)
+	// Storage: `TeyrchainSystem::RelevantMessagingState` (r:1 w:0)
+	// Proof: `TeyrchainSystem::RelevantMessagingState` (`max_values`: Some(1), `max_size`: None, mode: `Measured`)
+	// Storage: `XcmpQueue::OutboundXcmpStatus` (r:1 w:1)
+	// Proof: `XcmpQueue::OutboundXcmpStatus` (`max_values`: Some(1), `max_size`: Some(1282), added: 1777, mode: `MaxEncodedLen`)
+	// Storage: `XcmpQueue::OutboundXcmpMessages` (r:0 w:1)
+	// Proof: `XcmpQueue::OutboundXcmpMessages` (`max_values`: None, `max_size`: Some(105506), added: 107981, mode: `MaxEncodedLen`)
+	pub fn transfer_reserve_asset() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `345`
+		//  Estimated: `8799`
+		// Minimum execution time: 110_100_000 picoseconds.
+		Weight::from_parts(112_319_000, 8799)
+			.saturating_add(T::DbWeight::get().reads(8))
+			.saturating_add(T::DbWeight::get().writes(5))
+	}
+	// Storage: `Benchmark::Override` (r:0 w:0)
+	// Proof: `Benchmark::Override` (`max_values`: None, `max_size`: None, mode: `Measured`)
+	pub fn reserve_asset_deposited() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0`
+		//  Estimated: `0`
+		// Minimum execution time: 18_446_744_073_709_551_000 picoseconds.
+		Weight::from_parts(18_446_744_073_709_551_000, 0)
+	}
+	// Storage: `TeyrchainInfo::TeyrchainId` (r:1 w:0)
+	// Proof: `TeyrchainInfo::TeyrchainId` (`max_values`: Some(1), `max_size`: Some(4), added: 499, mode: `MaxEncodedLen`)
+	// Storage: `XcmpQueue::DeliveryFeeFactor` (r:1 w:0)
+	// Proof: `XcmpQueue::DeliveryFeeFactor` (`max_values`: None, `max_size`: Some(28), added: 2503, mode: `MaxEncodedLen`)
+	// Storage: `PezkuwiXcm::SupportedVersion` (r:1 w:0)
+	// Proof: `PezkuwiXcm::SupportedVersion` (`max_values`: None, `max_size`: None, mode: `Measured`)
+	// Storage: `System::Account` (r:2 w:2)
+	// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `MaxEncodedLen`)
+	// Storage: `TeyrchainSystem::RelevantMessagingState` (r:1 w:0)
+	// Proof: `TeyrchainSystem::RelevantMessagingState` (`max_values`: Some(1), `max_size`: None, mode: `Measured`)
+	// Storage: `XcmpQueue::OutboundXcmpStatus` (r:1 w:1)
+	// Proof: `XcmpQueue::OutboundXcmpStatus` (`max_values`: Some(1), `max_size`: Some(1282), added: 1777, mode: `MaxEncodedLen`)
+	// Storage: `XcmpQueue::OutboundXcmpMessages` (r:0 w:1)
+	// Proof: `XcmpQueue::OutboundXcmpMessages` (`max_values`: None, `max_size`: Some(105506), added: 107981, mode: `MaxEncodedLen`)
+	pub fn initiate_reserve_withdraw() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `345`
+		//  Estimated: `6196`
+		// Minimum execution time: 79_690_000 picoseconds.
+		Weight::from_parts(82_281_000, 6196)
+			.saturating_add(T::DbWeight::get().reads(7))
+			.saturating_add(T::DbWeight::get().writes(4))
+	}
+	pub fn receive_teleported_asset() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0`
+		//  Estimated: `0`
+		// Minimum execution time: 2_748_000 picoseconds.
+		Weight::from_parts(2_919_000, 0)
+	}
+	// Storage: `System::Account` (r:1 w:1)
+	// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `MaxEncodedLen`)
+	pub fn deposit_asset() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0`
+		//  Estimated: `3593`
+		// Minimum execution time: 24_264_000 picoseconds.
+		Weight::from_parts(24_701_000, 3593)
+			.saturating_add(T::DbWeight::get().reads(1))
+			.saturating_add(T::DbWeight::get().writes(1))
+	}
+	// Storage: `TeyrchainInfo::TeyrchainId` (r:1 w:0)
+	// Proof: `TeyrchainInfo::TeyrchainId` (`max_values`: Some(1), `max_size`: Some(4), added: 499, mode: `MaxEncodedLen`)
+	// Storage: `XcmpQueue::DeliveryFeeFactor` (r:1 w:0)
+	// Proof: `XcmpQueue::DeliveryFeeFactor` (`max_values`: None, `max_size`: Some(28), added: 2503, mode: `MaxEncodedLen`)
+	// Storage: `PezkuwiXcm::SupportedVersion` (r:1 w:0)
+	// Proof: `PezkuwiXcm::SupportedVersion` (`max_values`: None, `max_size`: None, mode: `Measured`)
+	// Storage: `System::Account` (r:1 w:1)
+	// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `MaxEncodedLen`)
+	// Storage: `TeyrchainSystem::RelevantMessagingState` (r:1 w:0)
+	// Proof: `TeyrchainSystem::RelevantMessagingState` (`max_values`: Some(1), `max_size`: None, mode: `Measured`)
+	// Storage: `XcmpQueue::OutboundXcmpStatus` (r:1 w:1)
+	// Proof: `XcmpQueue::OutboundXcmpStatus` (`max_values`: Some(1), `max_size`: Some(1282), added: 1777, mode: `MaxEncodedLen`)
+	// Storage: `XcmpQueue::OutboundXcmpMessages` (r:0 w:1)
+	// Proof: `XcmpQueue::OutboundXcmpMessages` (`max_values`: None, `max_size`: Some(105506), added: 107981, mode: `MaxEncodedLen`)
+	pub fn deposit_reserve_asset() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `244`
+		//  Estimated: `3709`
+		// Minimum execution time: 68_727_000 picoseconds.
+		Weight::from_parts(70_944_000, 3709)
+			.saturating_add(T::DbWeight::get().reads(6))
+			.saturating_add(T::DbWeight::get().writes(3))
+	}
+	// Storage: `TeyrchainInfo::TeyrchainId` (r:1 w:0)
+	// Proof: `TeyrchainInfo::TeyrchainId` (`max_values`: Some(1), `max_size`: Some(4), added: 499, mode: `MaxEncodedLen`)
+	// Storage: `XcmpQueue::DeliveryFeeFactor` (r:1 w:0)
+	// Proof: `XcmpQueue::DeliveryFeeFactor` (`max_values`: None, `max_size`: Some(28), added: 2503, mode: `MaxEncodedLen`)
+	// Storage: `PezkuwiXcm::SupportedVersion` (r:1 w:0)
+	// Proof: `PezkuwiXcm::SupportedVersion` (`max_values`: None, `max_size`: None, mode: `Measured`)
+	// Storage: `TeyrchainSystem::RelevantMessagingState` (r:1 w:0)
+	// Proof: `TeyrchainSystem::RelevantMessagingState` (`max_values`: Some(1), `max_size`: None, mode: `Measured`)
+	// Storage: `XcmpQueue::OutboundXcmpStatus` (r:1 w:1)
+	// Proof: `XcmpQueue::OutboundXcmpStatus` (`max_values`: Some(1), `max_size`: Some(1282), added: 1777, mode: `MaxEncodedLen`)
+	// Storage: `XcmpQueue::OutboundXcmpMessages` (r:0 w:1)
+	// Proof: `XcmpQueue::OutboundXcmpMessages` (`max_values`: None, `max_size`: Some(105506), added: 107981, mode: `MaxEncodedLen`)
+	pub fn initiate_teleport() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `244`
+		//  Estimated: `3709`
+		// Minimum execution time: 48_495_000 picoseconds.
+		Weight::from_parts(49_936_000, 3709)
+			.saturating_add(T::DbWeight::get().reads(5))
+			.saturating_add(T::DbWeight::get().writes(2))
+	}
+	// Storage: `System::Account` (r:2 w:2)
+	// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `MaxEncodedLen`)
+	// Storage: `TeyrchainInfo::TeyrchainId` (r:1 w:0)
+	// Proof: `TeyrchainInfo::TeyrchainId` (`max_values`: Some(1), `max_size`: Some(4), added: 499, mode: `MaxEncodedLen`)
+	// Storage: `XcmpQueue::DeliveryFeeFactor` (r:1 w:0)
+	// Proof: `XcmpQueue::DeliveryFeeFactor` (`max_values`: None, `max_size`: Some(28), added: 2503, mode: `MaxEncodedLen`)
+	// Storage: `PezkuwiXcm::SupportedVersion` (r:1 w:0)
+	// Proof: `PezkuwiXcm::SupportedVersion` (`max_values`: None, `max_size`: None, mode: `Measured`)
+	// Storage: `TeyrchainSystem::RelevantMessagingState` (r:1 w:0)
+	// Proof: `TeyrchainSystem::RelevantMessagingState` (`max_values`: Some(1), `max_size`: None, mode: `Measured`)
+	// Storage: `XcmpQueue::OutboundXcmpStatus` (r:1 w:1)
+	// Proof: `XcmpQueue::OutboundXcmpStatus` (`max_values`: Some(1), `max_size`: Some(1282), added: 1777, mode: `MaxEncodedLen`)
+	// Storage: `XcmpQueue::OutboundXcmpMessages` (r:0 w:1)
+	// Proof: `XcmpQueue::OutboundXcmpMessages` (`max_values`: None, `max_size`: Some(105506), added: 107981, mode: `MaxEncodedLen`)
+	pub fn initiate_transfer() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `244`
+		//  Estimated: `6196`
+		// Minimum execution time: 94_270_000 picoseconds.
+		Weight::from_parts(96_465_000, 6196)
+			.saturating_add(T::DbWeight::get().reads(7))
+			.saturating_add(T::DbWeight::get().writes(4))
+	}
+}

pezcumulus/teyrchains/runtimes/people/people-pezkuwichain/src/weights/xcm/pallet_xcm_benchmarks_generic.rs

@@ -0,0 +1,368 @@
+// 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_xcm_benchmarks::generic`
+//!
+//! THIS FILE WAS AUTO-GENERATED USING THE BIZINIKIWI BENCHMARK CLI VERSION 32.0.0
+//! DATE: 2025-07-30, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]`
+//! WORST CASE MAP SIZE: `1000000`
+//! HOSTNAME: `a49f76527979`, 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/people-pezkuwichain-runtime/people_pezkuwichain_runtime.wasm
+// --pallet=pezpallet_xcm_benchmarks::generic
+// --header=/__w/pezkuwi-sdk/pezkuwi-sdk/pezcumulus/file_header.txt
+// --output=./pezcumulus/teyrchains/runtimes/people/people-pezkuwichain/src/weights/xcm
+// --wasm-execution=compiled
+// --steps=50
+// --repeat=20
+// --heap-pages=4096
+// --template=pezcumulus/templates/xcm-bench-template.hbs
+// --no-storage-info
+// --no-min-squares
+// --no-median-slopes
+
+#![cfg_attr(rustfmt, rustfmt_skip)]
+#![allow(unused_parens)]
+#![allow(unused_imports)]
+
+use pezframe_support::{traits::Get, weights::Weight};
+use core::marker::PhantomData;
+
+/// Weights for `pezpallet_xcm_benchmarks::generic`.
+pub struct WeightInfo<T>(PhantomData<T>);
+impl<T: pezframe_system::Config> WeightInfo<T> {
+	// Storage: `TeyrchainInfo::TeyrchainId` (r:1 w:0)
+	// Proof: `TeyrchainInfo::TeyrchainId` (`max_values`: Some(1), `max_size`: Some(4), added: 499, mode: `MaxEncodedLen`)
+	// Storage: `XcmpQueue::DeliveryFeeFactor` (r:1 w:0)
+	// Proof: `XcmpQueue::DeliveryFeeFactor` (`max_values`: None, `max_size`: Some(28), added: 2503, mode: `MaxEncodedLen`)
+	// Storage: `PezkuwiXcm::SupportedVersion` (r:1 w:0)
+	// Proof: `PezkuwiXcm::SupportedVersion` (`max_values`: None, `max_size`: None, mode: `Measured`)
+	// Storage: `System::Account` (r:2 w:2)
+	// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `MaxEncodedLen`)
+	// Storage: `TeyrchainSystem::RelevantMessagingState` (r:1 w:0)
+	// Proof: `TeyrchainSystem::RelevantMessagingState` (`max_values`: Some(1), `max_size`: None, mode: `Measured`)
+	// Storage: `XcmpQueue::OutboundXcmpStatus` (r:1 w:1)
+	// Proof: `XcmpQueue::OutboundXcmpStatus` (`max_values`: Some(1), `max_size`: Some(1282), added: 1777, mode: `MaxEncodedLen`)
+	// Storage: `XcmpQueue::OutboundXcmpMessages` (r:0 w:1)
+	// Proof: `XcmpQueue::OutboundXcmpMessages` (`max_values`: None, `max_size`: Some(105506), added: 107981, mode: `MaxEncodedLen`)
+	pub fn report_holding() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `345`
+		//  Estimated: `6196`
+		// Minimum execution time: 76_734_000 picoseconds.
+		Weight::from_parts(79_192_000, 6196)
+			.saturating_add(T::DbWeight::get().reads(7))
+			.saturating_add(T::DbWeight::get().writes(4))
+	}
+	// Storage: `System::Account` (r:1 w:1)
+	// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `MaxEncodedLen`)
+	pub fn buy_execution() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0`
+		//  Estimated: `3593`
+		// Minimum execution time: 3_824_000 picoseconds.
+		Weight::from_parts(4_021_000, 3593)
+			.saturating_add(T::DbWeight::get().reads(1))
+			.saturating_add(T::DbWeight::get().writes(1))
+	}
+	// Storage: `System::Account` (r:1 w:1)
+	// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `MaxEncodedLen`)
+	pub fn pay_fees() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0`
+		//  Estimated: `3593`
+		// Minimum execution time: 3_653_000 picoseconds.
+		Weight::from_parts(3_956_000, 3593)
+			.saturating_add(T::DbWeight::get().reads(1))
+			.saturating_add(T::DbWeight::get().writes(1))
+	}
+	pub fn asset_claimer() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0`
+		//  Estimated: `0`
+		// Minimum execution time: 754_000 picoseconds.
+		Weight::from_parts(805_000, 0)
+	}
+	// Storage: `PezkuwiXcm::Queries` (r:1 w:0)
+	// Proof: `PezkuwiXcm::Queries` (`max_values`: None, `max_size`: None, mode: `Measured`)
+	pub fn query_response() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0`
+		//  Estimated: `3465`
+		// Minimum execution time: 5_858_000 picoseconds.
+		Weight::from_parts(6_017_000, 3465)
+			.saturating_add(T::DbWeight::get().reads(1))
+	}
+	pub fn transact() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0`
+		//  Estimated: `0`
+		// Minimum execution time: 7_376_000 picoseconds.
+		Weight::from_parts(7_673_000, 0)
+	}
+	pub fn refund_surplus() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0`
+		//  Estimated: `0`
+		// Minimum execution time: 1_183_000 picoseconds.
+		Weight::from_parts(1_246_000, 0)
+	}
+	pub fn set_error_handler() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0`
+		//  Estimated: `0`
+		// Minimum execution time: 742_000 picoseconds.
+		Weight::from_parts(801_000, 0)
+	}
+	pub fn set_appendix() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0`
+		//  Estimated: `0`
+		// Minimum execution time: 727_000 picoseconds.
+		Weight::from_parts(786_000, 0)
+	}
+	pub fn clear_error() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0`
+		//  Estimated: `0`
+		// Minimum execution time: 675_000 picoseconds.
+		Weight::from_parts(729_000, 0)
+	}
+	pub fn descend_origin() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0`
+		//  Estimated: `0`
+		// Minimum execution time: 764_000 picoseconds.
+		Weight::from_parts(793_000, 0)
+	}
+	// Storage: `Benchmark::Override` (r:0 w:0)
+	// Proof: `Benchmark::Override` (`max_values`: None, `max_size`: None, mode: `Measured`)
+	pub fn execute_with_origin() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0`
+		//  Estimated: `0`
+		// Minimum execution time: 18_446_744_073_709_551_000 picoseconds.
+		Weight::from_parts(18_446_744_073_709_551_000, 0)
+	}
+	pub fn clear_origin() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0`
+		//  Estimated: `0`
+		// Minimum execution time: 663_000 picoseconds.
+		Weight::from_parts(752_000, 0)
+	}
+	// Storage: `TeyrchainInfo::TeyrchainId` (r:1 w:0)
+	// Proof: `TeyrchainInfo::TeyrchainId` (`max_values`: Some(1), `max_size`: Some(4), added: 499, mode: `MaxEncodedLen`)
+	// Storage: `XcmpQueue::DeliveryFeeFactor` (r:1 w:0)
+	// Proof: `XcmpQueue::DeliveryFeeFactor` (`max_values`: None, `max_size`: Some(28), added: 2503, mode: `MaxEncodedLen`)
+	// Storage: `PezkuwiXcm::SupportedVersion` (r:1 w:0)
+	// Proof: `PezkuwiXcm::SupportedVersion` (`max_values`: None, `max_size`: None, mode: `Measured`)
+	// Storage: `System::Account` (r:2 w:2)
+	// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `MaxEncodedLen`)
+	// Storage: `TeyrchainSystem::RelevantMessagingState` (r:1 w:0)
+	// Proof: `TeyrchainSystem::RelevantMessagingState` (`max_values`: Some(1), `max_size`: None, mode: `Measured`)
+	// Storage: `XcmpQueue::OutboundXcmpStatus` (r:1 w:1)
+	// Proof: `XcmpQueue::OutboundXcmpStatus` (`max_values`: Some(1), `max_size`: Some(1282), added: 1777, mode: `MaxEncodedLen`)
+	// Storage: `XcmpQueue::OutboundXcmpMessages` (r:0 w:1)
+	// Proof: `XcmpQueue::OutboundXcmpMessages` (`max_values`: None, `max_size`: Some(105506), added: 107981, mode: `MaxEncodedLen`)
+	pub fn report_error() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `345`
+		//  Estimated: `6196`
+		// Minimum execution time: 73_512_000 picoseconds.
+		Weight::from_parts(75_381_000, 6196)
+			.saturating_add(T::DbWeight::get().reads(7))
+			.saturating_add(T::DbWeight::get().writes(4))
+	}
+	// Storage: `PezkuwiXcm::AssetTraps` (r:1 w:1)
+	// Proof: `PezkuwiXcm::AssetTraps` (`max_values`: None, `max_size`: None, mode: `Measured`)
+	pub fn claim_asset() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `24`
+		//  Estimated: `3489`
+		// Minimum execution time: 9_359_000 picoseconds.
+		Weight::from_parts(9_823_000, 3489)
+			.saturating_add(T::DbWeight::get().reads(1))
+			.saturating_add(T::DbWeight::get().writes(1))
+	}
+	pub fn trap() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0`
+		//  Estimated: `0`
+		// Minimum execution time: 3_402_000 picoseconds.
+		Weight::from_parts(3_585_000, 0)
+	}
+	// Storage: `PezkuwiXcm::VersionNotifyTargets` (r:1 w:1)
+	// Proof: `PezkuwiXcm::VersionNotifyTargets` (`max_values`: None, `max_size`: None, mode: `Measured`)
+	// Storage: `XcmpQueue::DeliveryFeeFactor` (r:1 w:0)
+	// Proof: `XcmpQueue::DeliveryFeeFactor` (`max_values`: None, `max_size`: Some(28), added: 2503, mode: `MaxEncodedLen`)
+	// Storage: `PezkuwiXcm::SupportedVersion` (r:1 w:0)
+	// Proof: `PezkuwiXcm::SupportedVersion` (`max_values`: None, `max_size`: None, mode: `Measured`)
+	// Storage: `TeyrchainSystem::RelevantMessagingState` (r:1 w:0)
+	// Proof: `TeyrchainSystem::RelevantMessagingState` (`max_values`: Some(1), `max_size`: None, mode: `Measured`)
+	// Storage: `XcmpQueue::OutboundXcmpStatus` (r:1 w:1)
+	// Proof: `XcmpQueue::OutboundXcmpStatus` (`max_values`: Some(1), `max_size`: Some(1282), added: 1777, mode: `MaxEncodedLen`)
+	// Storage: `XcmpQueue::OutboundXcmpMessages` (r:0 w:1)
+	// Proof: `XcmpQueue::OutboundXcmpMessages` (`max_values`: None, `max_size`: Some(105506), added: 107981, mode: `MaxEncodedLen`)
+	pub fn subscribe_version() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `175`
+		//  Estimated: `3640`
+		// Minimum execution time: 31_686_000 picoseconds.
+		Weight::from_parts(32_742_000, 3640)
+			.saturating_add(T::DbWeight::get().reads(5))
+			.saturating_add(T::DbWeight::get().writes(3))
+	}
+	// Storage: `PezkuwiXcm::VersionNotifyTargets` (r:0 w:1)
+	// Proof: `PezkuwiXcm::VersionNotifyTargets` (`max_values`: None, `max_size`: None, mode: `Measured`)
+	pub fn unsubscribe_version() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0`
+		//  Estimated: `0`
+		// Minimum execution time: 3_091_000 picoseconds.
+		Weight::from_parts(3_327_000, 0)
+			.saturating_add(T::DbWeight::get().writes(1))
+	}
+	pub fn burn_asset() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0`
+		//  Estimated: `0`
+		// Minimum execution time: 1_069_000 picoseconds.
+		Weight::from_parts(1_126_000, 0)
+	}
+	pub fn expect_asset() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0`
+		//  Estimated: `0`
+		// Minimum execution time: 769_000 picoseconds.
+		Weight::from_parts(847_000, 0)
+	}
+	pub fn expect_origin() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0`
+		//  Estimated: `0`
+		// Minimum execution time: 3_459_000 picoseconds.
+		Weight::from_parts(3_616_000, 0)
+	}
+	pub fn expect_error() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0`
+		//  Estimated: `0`
+		// Minimum execution time: 3_456_000 picoseconds.
+		Weight::from_parts(3_631_000, 0)
+	}
+	pub fn expect_transact_status() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0`
+		//  Estimated: `0`
+		// Minimum execution time: 846_000 picoseconds.
+		Weight::from_parts(925_000, 0)
+	}
+	// Storage: `TeyrchainInfo::TeyrchainId` (r:1 w:0)
+	// Proof: `TeyrchainInfo::TeyrchainId` (`max_values`: Some(1), `max_size`: Some(4), added: 499, mode: `MaxEncodedLen`)
+	// Storage: `XcmpQueue::DeliveryFeeFactor` (r:1 w:0)
+	// Proof: `XcmpQueue::DeliveryFeeFactor` (`max_values`: None, `max_size`: Some(28), added: 2503, mode: `MaxEncodedLen`)
+	// Storage: `PezkuwiXcm::SupportedVersion` (r:1 w:0)
+	// Proof: `PezkuwiXcm::SupportedVersion` (`max_values`: None, `max_size`: None, mode: `Measured`)
+	// Storage: `System::Account` (r:2 w:2)
+	// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `MaxEncodedLen`)
+	// Storage: `TeyrchainSystem::RelevantMessagingState` (r:1 w:0)
+	// Proof: `TeyrchainSystem::RelevantMessagingState` (`max_values`: Some(1), `max_size`: None, mode: `Measured`)
+	// Storage: `XcmpQueue::OutboundXcmpStatus` (r:1 w:1)
+	// Proof: `XcmpQueue::OutboundXcmpStatus` (`max_values`: Some(1), `max_size`: Some(1282), added: 1777, mode: `MaxEncodedLen`)
+	// Storage: `XcmpQueue::OutboundXcmpMessages` (r:0 w:1)
+	// Proof: `XcmpQueue::OutboundXcmpMessages` (`max_values`: None, `max_size`: Some(105506), added: 107981, mode: `MaxEncodedLen`)
+	pub fn query_pallet() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `345`
+		//  Estimated: `6196`
+		// Minimum execution time: 77_788_000 picoseconds.
+		Weight::from_parts(80_423_000, 6196)
+			.saturating_add(T::DbWeight::get().reads(7))
+			.saturating_add(T::DbWeight::get().writes(4))
+	}
+	pub fn expect_pallet() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0`
+		//  Estimated: `0`
+		// Minimum execution time: 3_723_000 picoseconds.
+		Weight::from_parts(3_891_000, 0)
+	}
+	// Storage: `TeyrchainInfo::TeyrchainId` (r:1 w:0)
+	// Proof: `TeyrchainInfo::TeyrchainId` (`max_values`: Some(1), `max_size`: Some(4), added: 499, mode: `MaxEncodedLen`)
+	// Storage: `XcmpQueue::DeliveryFeeFactor` (r:1 w:0)
+	// Proof: `XcmpQueue::DeliveryFeeFactor` (`max_values`: None, `max_size`: Some(28), added: 2503, mode: `MaxEncodedLen`)
+	// Storage: `PezkuwiXcm::SupportedVersion` (r:1 w:0)
+	// Proof: `PezkuwiXcm::SupportedVersion` (`max_values`: None, `max_size`: None, mode: `Measured`)
+	// Storage: `System::Account` (r:2 w:2)
+	// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `MaxEncodedLen`)
+	// Storage: `TeyrchainSystem::RelevantMessagingState` (r:1 w:0)
+	// Proof: `TeyrchainSystem::RelevantMessagingState` (`max_values`: Some(1), `max_size`: None, mode: `Measured`)
+	// Storage: `XcmpQueue::OutboundXcmpStatus` (r:1 w:1)
+	// Proof: `XcmpQueue::OutboundXcmpStatus` (`max_values`: Some(1), `max_size`: Some(1282), added: 1777, mode: `MaxEncodedLen`)
+	// Storage: `XcmpQueue::OutboundXcmpMessages` (r:0 w:1)
+	// Proof: `XcmpQueue::OutboundXcmpMessages` (`max_values`: None, `max_size`: Some(105506), added: 107981, mode: `MaxEncodedLen`)
+	pub fn report_transact_status() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `345`
+		//  Estimated: `6196`
+		// Minimum execution time: 74_903_000 picoseconds.
+		Weight::from_parts(76_835_000, 6196)
+			.saturating_add(T::DbWeight::get().reads(7))
+			.saturating_add(T::DbWeight::get().writes(4))
+	}
+	pub fn clear_transact_status() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0`
+		//  Estimated: `0`
+		// Minimum execution time: 715_000 picoseconds.
+		Weight::from_parts(786_000, 0)
+	}
+	pub fn set_topic() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0`
+		//  Estimated: `0`
+		// Minimum execution time: 686_000 picoseconds.
+		Weight::from_parts(741_000, 0)
+	}
+	pub fn clear_topic() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0`
+		//  Estimated: `0`
+		// Minimum execution time: 677_000 picoseconds.
+		Weight::from_parts(738_000, 0)
+	}
+	pub fn set_fees_mode() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0`
+		//  Estimated: `0`
+		// Minimum execution time: 687_000 picoseconds.
+		Weight::from_parts(745_000, 0)
+	}
+	pub fn unpaid_execution() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0`
+		//  Estimated: `0`
+		// Minimum execution time: 704_000 picoseconds.
+		Weight::from_parts(748_000, 0)
+	}
+}

pezcumulus/teyrchains/runtimes/people/people-pezkuwichain/src/xcm_config.rs

@@ -0,0 +1,292 @@
+// 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.
+
+use super::{
+	AccountId, AllPalletsWithSystem, Balances, PezkuwiXcm, Runtime, RuntimeCall, RuntimeEvent,
+	RuntimeOrigin, TeyrchainInfo, TeyrchainSystem, WeightToFee, XcmpQueue,
+};
+use crate::{TransactionByteFee, CENTS};
+use pezframe_support::{
+	parameter_types,
+	traits::{
+		tokens::imbalance::ResolveTo, ConstU32, Contains, Disabled, Equals, Everything, Nothing,
+	},
+};
+use pezframe_system::EnsureRoot;
+use pezpallet_collator_selection::StakingPotAccountId;
+use pezpallet_xcm::XcmPassthrough;
+use pezkuwi_teyrchain_primitives::primitives::Sibling;
+use pezsp_runtime::traits::AccountIdConversion;
+use teyrchains_common::{
+	xcm_config::{
+		AllSiblingSystemTeyrchains, ConcreteAssetFromSystem, ParentRelayOrSiblingTeyrchains,
+		RelayOrOtherSystemTeyrchains,
+	},
+	TREASURY_PALLET_ID,
+};
+use xcm::latest::{prelude::*, PEZKUWICHAIN_GENESIS_HASH};
+use xcm_builder::{
+	AccountId32Aliases, AllowExplicitUnpaidExecutionFrom, AllowHrmpNotificationsFromRelayChain,
+	AllowKnownQueryResponses, AllowSubscriptionsFrom, AllowTopLevelPaidExecutionFrom,
+	DenyRecursively, DenyReserveTransferToRelayChain, DenyThenTry, DescribeAllTerminal,
+	DescribeFamily, DescribeTerminus, EnsureXcmOrigin, FrameTransactionalProcessor,
+	FungibleAdapter, HashedDescription, IsConcrete, ParentAsSuperuser, ParentIsPreset,
+	RelayChainAsNative, SendXcmFeeToAccount, SiblingTeyrchainAsNative, SiblingTeyrchainConvertsVia,
+	SignedAccountId32AsNative, SignedToAccountId32, SovereignSignedViaLocation, TakeWeightCredit,
+	TrailingSetTopicAsId, UsingComponents, WeightInfoBounds, WithComputedOrigin, WithUniqueTopic,
+	XcmFeeManagerFromComponents,
+};
+use xcm_executor::XcmExecutor;
+
+parameter_types! {
+	pub const RootLocation: Location = Location::here();
+	pub const RelayLocation: Location = Location::parent();
+	pub const RelayNetwork: Option<NetworkId> = Some(NetworkId::ByGenesis(PEZKUWICHAIN_GENESIS_HASH));
+	pub RelayChainOrigin: RuntimeOrigin = cumulus_pallet_xcm::Origin::Relay.into();
+	pub UniversalLocation: InteriorLocation =
+		[GlobalConsensus(RelayNetwork::get().unwrap()), Teyrchain(TeyrchainInfo::teyrchain_id().into())].into();
+	pub const MaxInstructions: u32 = 100;
+	pub const MaxAssetsIntoHolding: u32 = 64;
+	pub const GovernanceLocation: Location = Location::parent();
+	pub const FellowshipLocation: Location = Location::parent();
+	/// The asset ID for the asset that we use to pay for message delivery fees. Just TYR.
+	pub FeeAssetId: AssetId = AssetId(RelayLocation::get());
+	/// The base fee for the message delivery fees.
+	pub const BaseDeliveryFee: u128 = CENTS.saturating_mul(3);
+	pub TreasuryAccount: AccountId = TREASURY_PALLET_ID.into_account_truncating();
+	pub RelayTreasuryLocation: Location =
+		(Parent, PalletInstance(pezkuwichain_runtime_constants::TREASURY_PALLET_ID)).into();
+}
+
+pub type PriceForParentDelivery = pezkuwi_runtime_common::xcm_sender::ExponentialPrice<
+	FeeAssetId,
+	BaseDeliveryFee,
+	TransactionByteFee,
+	TeyrchainSystem,
+>;
+
+pub type PriceForSiblingTeyrchainDelivery = pezkuwi_runtime_common::xcm_sender::ExponentialPrice<
+	FeeAssetId,
+	BaseDeliveryFee,
+	TransactionByteFee,
+	XcmpQueue,
+>;
+
+/// Type for specifying how a `Location` can be converted into an `AccountId`. This is used
+/// when determining ownership of accounts for asset transacting and when attempting to use XCM
+/// `Transact` in order to determine the dispatch Origin.
+pub type LocationToAccountId = (
+	// The parent (Relay-chain) origin converts to the parent `AccountId`.
+	ParentIsPreset<AccountId>,
+	// Sibling teyrchain origins convert to AccountId via the `ParaId::into`.
+	SiblingTeyrchainConvertsVia<Sibling, AccountId>,
+	// Straight up local `AccountId32` origins just alias directly to `AccountId`.
+	AccountId32Aliases<RelayNetwork, AccountId>,
+	// Here/local root location to `AccountId`.
+	HashedDescription<AccountId, DescribeTerminus>,
+	// Foreign locations alias into accounts according to a hash of their standard description.
+	HashedDescription<AccountId, DescribeFamily<DescribeAllTerminal>>,
+);
+
+/// Means for transacting the native currency on this chain.
+pub type FungibleTransactor = FungibleAdapter<
+	// Use this currency:
+	Balances,
+	// Use this currency when it is a fungible asset matching the given location or name:
+	IsConcrete<RelayLocation>,
+	// Do a simple punn to convert an `AccountId32` `Location` into a native chain
+	// `AccountId`:
+	LocationToAccountId,
+	// Our chain's `AccountId` type (we can't get away without mentioning it explicitly):
+	AccountId,
+	// We don't track any teleports of `Balances`.
+	(),
+>;
+
+/// This is the type we use to convert an (incoming) XCM origin into a local `Origin` instance,
+/// ready for dispatching a transaction with XCM's `Transact`. There is an `OriginKind` that can
+/// bias the kind of local `Origin` it will become.
+pub type XcmOriginToTransactDispatchOrigin = (
+	// Sovereign account converter; this attempts to derive an `AccountId` from the origin location
+	// using `LocationToAccountId` and then turn that into the usual `Signed` origin. Useful for
+	// foreign chains who want to have a local sovereign account on this chain that they control.
+	SovereignSignedViaLocation<LocationToAccountId, RuntimeOrigin>,
+	// Native converter for Relay-chain (Parent) location; will convert to a `Relay` origin when
+	// recognized.
+	RelayChainAsNative<RelayChainOrigin, RuntimeOrigin>,
+	// Native converter for sibling Teyrchains; will convert to a `SiblingPara` origin when
+	// recognized.
+	SiblingTeyrchainAsNative<cumulus_pallet_xcm::Origin, RuntimeOrigin>,
+	// Superuser converter for the Relay-chain (Parent) location. This will allow it to issue a
+	// transaction from the Root origin.
+	ParentAsSuperuser<RuntimeOrigin>,
+	// Native signed account converter; this just converts an `AccountId32` origin into a normal
+	// `RuntimeOrigin::Signed` origin of the same 32-byte value.
+	SignedAccountId32AsNative<RelayNetwork, RuntimeOrigin>,
+	// XCM origins can be represented natively under the XCM pallet's `Xcm` origin.
+	XcmPassthrough<RuntimeOrigin>,
+);
+
+pub struct LocalPlurality;
+impl Contains<Location> for LocalPlurality {
+	fn contains(location: &Location) -> bool {
+		matches!(location.unpack(), (0, [Plurality { .. }]))
+	}
+}
+
+pub struct ParentOrParentsPlurality;
+impl Contains<Location> for ParentOrParentsPlurality {
+	fn contains(location: &Location) -> bool {
+		matches!(location.unpack(), (1, []) | (1, [Plurality { .. }]))
+	}
+}
+
+pub type Barrier = TrailingSetTopicAsId<
+	DenyThenTry<
+		DenyRecursively<DenyReserveTransferToRelayChain>,
+		(
+			// Allow local users to buy weight credit.
+			TakeWeightCredit,
+			// Expected responses are OK.
+			AllowKnownQueryResponses<PezkuwiXcm>,
+			WithComputedOrigin<
+				(
+					// If the message is one that immediately attempts to pay for execution, then
+					// allow it.
+					AllowTopLevelPaidExecutionFrom<Everything>,
+					// Parent and its pluralities (i.e. governance bodies) get free execution.
+					AllowExplicitUnpaidExecutionFrom<ParentOrParentsPlurality>,
+					// Subscriptions for version tracking are OK.
+					AllowSubscriptionsFrom<ParentRelayOrSiblingTeyrchains>,
+					// HRMP notifications from the relay chain are OK.
+					AllowHrmpNotificationsFromRelayChain,
+				),
+				UniversalLocation,
+				ConstU32<8>,
+			>,
+		),
+	>,
+>;
+
+/// Locations that will not be charged fees in the executor, neither for execution nor delivery. We
+/// only waive fees for system functions, which these locations represent.
+pub type WaivedLocations = (
+	RelayOrOtherSystemTeyrchains<AllSiblingSystemTeyrchains, Runtime>,
+	Equals<RelayTreasuryLocation>,
+	Equals<RootLocation>,
+	LocalPlurality,
+);
+
+pub struct XcmConfig;
+impl xcm_executor::Config for XcmConfig {
+	type RuntimeCall = RuntimeCall;
+	type XcmSender = XcmRouter;
+	type XcmEventEmitter = PezkuwiXcm;
+	type AssetTransactor = FungibleTransactor;
+	type OriginConverter = XcmOriginToTransactDispatchOrigin;
+	// People chain does not recognize a reserve location for any asset. Users must teleport TYR
+	// where allowed (e.g. with the Relay Chain).
+	type IsReserve = ();
+	/// Only allow teleportation of TYR.
+	type IsTeleporter = ConcreteAssetFromSystem<RelayLocation>;
+	type UniversalLocation = UniversalLocation;
+	type Barrier = Barrier;
+	type Weigher = WeightInfoBounds<
+		crate::weights::xcm::PeoplePezkuwichainXcmWeight<RuntimeCall>,
+		RuntimeCall,
+		MaxInstructions,
+	>;
+	type Trader = UsingComponents<
+		WeightToFee,
+		RelayLocation,
+		AccountId,
+		Balances,
+		ResolveTo<StakingPotAccountId<Runtime>, Balances>,
+	>;
+	type ResponseHandler = PezkuwiXcm;
+	type AssetTrap = PezkuwiXcm;
+	type AssetClaims = PezkuwiXcm;
+	type SubscriptionService = PezkuwiXcm;
+	type PalletInstancesInfo = AllPalletsWithSystem;
+	type MaxAssetsIntoHolding = MaxAssetsIntoHolding;
+	type AssetLocker = ();
+	type AssetExchanger = ();
+	type FeeManager = XcmFeeManagerFromComponents<
+		WaivedLocations,
+		SendXcmFeeToAccount<Self::AssetTransactor, TreasuryAccount>,
+	>;
+	type MessageExporter = ();
+	type UniversalAliases = Nothing;
+	type CallDispatcher = RuntimeCall;
+	type SafeCallFilter = Everything;
+	type Aliasers = Nothing;
+	type TransactionalProcessor = FrameTransactionalProcessor;
+	type HrmpNewChannelOpenRequestHandler = ();
+	type HrmpChannelAcceptedHandler = ();
+	type HrmpChannelClosingHandler = ();
+	type XcmRecorder = PezkuwiXcm;
+}
+
+/// Converts a local signed origin into an XCM location. Forms the basis for local origins
+/// sending/executing XCMs.
+pub type LocalOriginToLocation = SignedToAccountId32<RuntimeOrigin, AccountId, RelayNetwork>;
+
+/// The means for routing XCM messages which are not for local execution into the right message
+/// queues.
+pub type XcmRouter = WithUniqueTopic<(
+	// Two routers - use UMP to communicate with the relay chain:
+	cumulus_primitives_utility::ParentAsUmp<TeyrchainSystem, PezkuwiXcm, PriceForParentDelivery>,
+	// ..and XCMP to communicate with the sibling chains.
+	XcmpQueue,
+)>;
+
+impl pezpallet_xcm::Config for Runtime {
+	type RuntimeEvent = RuntimeEvent;
+	// We want to disallow users sending (arbitrary) XCM programs from this chain.
+	type SendXcmOrigin = EnsureXcmOrigin<RuntimeOrigin, ()>;
+	type XcmRouter = XcmRouter;
+	// We support local origins dispatching XCM executions.
+	type ExecuteXcmOrigin = EnsureXcmOrigin<RuntimeOrigin, LocalOriginToLocation>;
+	type XcmExecuteFilter = Everything;
+	type XcmExecutor = XcmExecutor<XcmConfig>;
+	type XcmTeleportFilter = Everything;
+	type XcmReserveTransferFilter = Nothing; // This teyrchain is not meant as a reserve location.
+	type Weigher = WeightInfoBounds<
+		crate::weights::xcm::PeoplePezkuwichainXcmWeight<RuntimeCall>,
+		RuntimeCall,
+		MaxInstructions,
+	>;
+	type UniversalLocation = UniversalLocation;
+	type RuntimeOrigin = RuntimeOrigin;
+	type RuntimeCall = RuntimeCall;
+	const VERSION_DISCOVERY_QUEUE_SIZE: u32 = 100;
+	type AdvertisedXcmVersion = pezpallet_xcm::CurrentXcmVersion;
+	type Currency = Balances;
+	type CurrencyMatcher = ();
+	type TrustedLockers = ();
+	type SovereignAccountOf = LocationToAccountId;
+	type MaxLockers = ConstU32<8>;
+	type WeightInfo = crate::weights::pezpallet_xcm::WeightInfo<Runtime>;
+	type AdminOrigin = EnsureRoot<AccountId>;
+	type MaxRemoteLockConsumers = ConstU32<0>;
+	type RemoteLockConsumerIdentifier = ();
+	// Aliasing is disabled: xcm_executor::Config::Aliasers is set to `Nothing`.
+	type AuthorizedAliasConsideration = Disabled;
+}
+
+impl cumulus_pallet_xcm::Config for Runtime {
+	type RuntimeEvent = RuntimeEvent;
+	type XcmExecutor = XcmExecutor<XcmConfig>;
+}