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/pallets/tiki/src/lib.rs

@@ -0,0 +1,864 @@
+#![cfg_attr(not(feature = "std"), no_std)]
+
+//! # Tiki (Role) Pallet
+//!
+//! A pallet for managing citizenship and role-based NFTs with automated and governance-driven
+//! assignment.
+//!
+//! ## Overview
+//!
+//! The Tiki pallet implements a comprehensive role management system using non-transferable NFTs
+//! to represent citizenship status and various roles within the ecosystem. Each role grants
+//! specific permissions, rights, and social standing.
+//!
+//! ## Core Concepts
+//!
+//! ### Citizenship NFT
+//! - Automatically minted upon KYC approval
+//! - Represents "Welati" (Citizen) status
+//! - Non-transferable and permanent
+//! - Required prerequisite for all other roles
+//!
+//! ### Role Types (Tiki)
+//!
+//! Roles are assigned through different mechanisms:
+//!
+//! 1. **Automatic** - System-assigned upon conditions (e.g., Citizenship after KYC)
+//! 2. **Appointed** - Admin-assigned governmental positions (e.g., Ministers, Judges)
+//! 3. **Elected** - Community-voted positions (e.g., Parliament members)
+//! 4. **Earned** - Achievement-based roles (e.g., Educator, Expert)
+//!
+//! ### Role Categories
+//!
+//! - **Governance**: Serok (President), SerokWeziran (Prime Minister), Ministers
+//! - **Judicial**: Dadger (Judge), Dozger (Prosecutor), Hiquqnas (Lawyer)
+//! - **Administrative**: Qeydkar (Registrar), Xezinedar (Treasurer), OperatorêTorê (Network
+//!   Operator)
+//! - **Educational**: Mamoste (Teacher), Perwerdekar (Educator), Rewsenbîr (Intellectual)
+//! - **Economic**: Bazargan (Merchant), Navbeynkar (Mediator)
+//! - **Community**: Parlementer (Parliament Member), ModeratorêCivakê (Community Moderator)
+//! - **Expert**: Axa (Elder/Expert), Pêseng (Pioneer), Hekem (Wise), Sêwirmend (Counselor)
+//!
+//! ## NFT Implementation
+//!
+//! - Built on top of `pezpallet-nfts` for standard NFT functionality
+//! - All Tiki NFTs are non-transferable (soulbound)
+//! - Transfer attempts are blocked automatically via hooks
+//! - Each role is represented by a unique NFT item in the TikiCollectionId
+//!
+//! ## Role Management
+//!
+//! ### Granting Roles
+//! - Some roles are unique (only one holder at a time)
+//! - Users can hold multiple compatible roles
+//! - Maximum roles per user is configurable
+//! - Trust score requirements for certain roles
+//!
+//! ### Revoking Roles
+//! - Admin can revoke appointed roles
+//! - Automatic revocation on condition changes
+//! - Role history maintained for governance transparency
+//!
+//! ## Interface
+//!
+//! ### Extrinsics
+//!
+//! - `grant_tiki(who, tiki, assignment_type)` - Assign a role to a user (admin)
+//! - `revoke_tiki(who, tiki)` - Remove a role from a user (admin)
+//! - `force_mint_citizen_nft(who)` - Manually mint citizenship NFT (admin)
+//!
+//! ### Storage
+//!
+//! - `CitizenNft` - Mapping of accounts to their citizenship NFT IDs
+//! - `UserTikis` - List of roles held by each user
+//! - `TikiHolder` - Reverse mapping for unique roles to their holders
+//! - `NextItemId` - Counter for NFT item ID generation
+//!
+//! ### Hooks
+//!
+//! - `on_initialize` - Automatic citizenship NFT minting for newly approved KYC users
+//! - NFT transfer blocking for all Tiki NFTs
+//!
+//! ## Dependencies
+//!
+//! This pallet requires integration with:
+//! - `pezpallet-identity-kyc` - KYC status and approval notifications
+//! - `pezpallet-nfts` - Underlying NFT infrastructure
+//! - `pezpallet-trust` - Trust score verification for role eligibility
+//!
+//! ## Runtime Integration Example
+//!
+//! ```ignore
+//! impl pezpallet_tiki::Config for Runtime {
+//!     type RuntimeEvent = RuntimeEvent;
+//!     type AdminOrigin = EnsureRoot<AccountId>;
+//!     type WeightInfo = pezpallet_tiki::weights::BizinikiwiWeight<Runtime>;
+//!     type TikiCollectionId = ConstU32<1>; // Tiki collection ID
+//!     type MaxTikisPerUser = ConstU32<20>; // Max 20 roles per user
+//!     type Tiki = pezpallet_tiki::Tiki;
+//! }
+//! ```
+
+extern crate alloc;
+
+pub use pallet::*;
+
+use alloc::{format, vec::Vec};
+use pezframe_support::pezpallet_prelude::{MaybeSerializeDeserialize, Parameter, RuntimeDebug};
+use scale_info::TypeInfo;
+use serde::{Deserialize, Serialize};
+use pezsp_runtime::DispatchError;
+
+#[cfg(feature = "runtime-benchmarks")]
+mod benchmarking;
+#[cfg(test)]
+mod mock;
+#[cfg(test)]
+mod tests;
+pub mod weights;
+pub use weights::*;
+pub mod ensure;
+pub mod migrations; // Storage migrations // For origin validation
+
+#[pezframe_support::pallet]
+pub mod pallet {
+	use super::*;
+	use pezframe_support::pezpallet_prelude::*;
+	use pezframe_system::pezpallet_prelude::*;
+	use pezsp_runtime::traits::StaticLookup;
+
+	#[pallet::pallet]
+	#[pallet::storage_version(migrations::STORAGE_VERSION)]
+	pub struct Pallet<T>(_);
+
+	#[pallet::config]
+	pub trait Config:
+		pezframe_system::Config + pezpallet_nfts::Config<ItemId = u32> + pezpallet_identity_kyc::Config
+	{
+		type RuntimeEvent: From<Event<Self>> + IsType<<Self as pezframe_system::Config>::RuntimeEvent>;
+		type AdminOrigin: EnsureOrigin<Self::RuntimeOrigin>;
+		type WeightInfo: weights::WeightInfo;
+
+		/// Collection ID holding Tiki (Role) NFTs.
+		#[pallet::constant]
+		type TikiCollectionId: Get<Self::CollectionId>;
+
+		/// Technical upper limit for maximum number of Tikis (roles) a user can hold.
+		#[pallet::constant]
+		type MaxTikisPerUser: Get<u32>;
+
+		/// Tiki enum type to be used within the pallet.
+		type Tiki: Parameter
+			+ From<Tiki>
+			+ Into<u32>
+			+ MaxEncodedLen
+			+ TypeInfo
+			+ Copy
+			+ MaybeSerializeDeserialize
+			+ 'static;
+	}
+
+	#[derive(
+		Serialize,
+		Deserialize,
+		Encode,
+		Decode,
+		DecodeWithMemTracking,
+		Clone,
+		Eq,
+		PartialEq,
+		RuntimeDebug,
+		TypeInfo,
+		MaxEncodedLen,
+		Copy,
+	)]
+	pub enum RoleAssignmentType {
+		/// Automatically assigned roles (like Welati after KYC)
+		Automatic,
+		/// Admin-assigned roles (like Wezir, Dadger)
+		Appointed,
+		/// Community-elected roles (like Parlementer) - assigned by pezpallet-voting
+		Elected,
+		/// Earned roles (Axa, roles obtained through exams)
+		Earned,
+	}
+
+	#[derive(
+		Serialize,
+		Deserialize,
+		Encode,
+		Decode,
+		DecodeWithMemTracking,
+		Clone,
+		Eq,
+		PartialEq,
+		RuntimeDebug,
+		TypeInfo,
+		MaxEncodedLen,
+		Copy,
+	)]
+	#[repr(u32)]
+	pub enum Tiki {
+		Welati,
+		Parlementer,
+		SerokiMeclise,
+		Serok,
+		Wezir,
+		EndameDiwane,
+		Dadger,
+		Dozger,
+		Hiquqnas,
+		Noter,
+		Xezinedar,
+		Bacgir,
+		GerinendeyeCavkaniye,
+		OperatorêTorê,
+		PisporêEwlehiyaSîber,
+		GerinendeyeDaneye,
+		Berdevk,
+		Qeydkar,
+		Balyoz,
+		Navbeynkar,
+		ParêzvaneÇandî,
+		Mufetîs,
+		KalîteKontrolker,
+		Mela,
+		Feqî,
+		Perwerdekar,
+		Rewsenbîr,
+		RêveberêProjeyê,
+		SerokêKomele,
+		ModeratorêCivakê,
+		Axa,
+		Pêseng,
+		Sêwirmend,
+		Hekem,
+		Mamoste,
+		// Newly added economic roles
+		Bazargan,
+		// Government roles
+		SerokWeziran,
+		WezireDarayiye,
+		WezireParez,
+		WezireDad,
+		WezireBelaw,
+		WezireTend,
+		WezireAva,
+		WezireCand,
+	}
+
+	impl From<Tiki> for u32 {
+		fn from(val: Tiki) -> Self {
+			val as u32
+		}
+	}
+
+	/// Holds citizenship NFT ID for each user
+	#[pallet::storage]
+	#[pallet::getter(fn citizen_nft)]
+	pub type CitizenNft<T: Config> =
+		StorageMap<_, Blake2_128Concat, T::AccountId, u32, OptionQuery>;
+
+	/// List of Tikis (roles) owned by each user
+	#[pallet::storage]
+	#[pallet::getter(fn user_tikis)]
+	pub type UserTikis<T: Config> = StorageMap<
+		_,
+		Blake2_128Concat,
+		T::AccountId,
+		BoundedVec<Tiki, T::MaxTikisPerUser>,
+		ValueQuery,
+	>;
+
+	/// Shows which user a specific Tiki belongs to (for unique roles)
+	#[pallet::storage]
+	#[pallet::getter(fn tiki_holder)]
+	pub type TikiHolder<T: Config> =
+		StorageMap<_, Blake2_128Concat, Tiki, T::AccountId, OptionQuery>;
+
+	/// Item ID to be used for next NFT
+	#[pallet::storage]
+	#[pallet::getter(fn next_item_id)]
+	pub type NextItemId<T: Config> = StorageValue<_, u32, ValueQuery>;
+
+	#[pallet::error]
+	pub enum Error<T> {
+		/// Role already belongs to someone else
+		RoleAlreadyTaken,
+		/// Specified person is not the holder of this role
+		NotTheHolder,
+		/// Role not assigned
+		RoleNotAssigned,
+		/// A user has reached maximum role count
+		ExceedsMaxRolesPerUser,
+		/// KYC not completed
+		KycNotCompleted,
+		/// Citizenship NFT already exists
+		CitizenNftAlreadyExists,
+		/// Citizenship NFT not found
+		CitizenNftNotFound,
+		/// User already has this role
+		UserAlreadyHasRole,
+		/// Insufficient Trust Score
+		InsufficientTrustScore,
+		/// This role type cannot be assigned with this method
+		InvalidRoleAssignmentMethod,
+	}
+
+	#[pallet::event]
+	#[pallet::generate_deposit(pub(super) fn deposit_event)]
+	pub enum Event<T: Config> {
+		/// New citizenship NFT minted
+		CitizenNftMinted { who: T::AccountId, nft_id: u32 },
+		/// New Tiki (role) granted
+		TikiGranted { who: T::AccountId, tiki: Tiki },
+		/// Tiki (role) revoked
+		TikiRevoked { who: T::AccountId, tiki: Tiki },
+		/// NFT transfer blocked
+		TransferBlocked {
+			collection_id: T::CollectionId,
+			item_id: u32,
+			from: T::AccountId,
+			to: T::AccountId,
+		},
+	}
+
+	#[pallet::hooks]
+	impl<T: Config> Hooks<BlockNumberFor<T>> for Pallet<T> {
+		fn on_initialize(_block_number: BlockNumberFor<T>) -> Weight {
+			// Check newly KYC-approved users and mint citizenship NFT
+			Self::check_and_mint_citizen_nfts();
+
+			T::DbWeight::get().reads_writes(10, 5)
+		}
+	}
+
+	#[pallet::call]
+	impl<T: Config> Pallet<T> {
+		/// Admin tarafından belirli bir kullanıcıya Tiki (rol) verme
+		#[pallet::call_index(0)]
+		#[pallet::weight(<T as crate::pallet::Config>::WeightInfo::grant_tiki())]
+		pub fn grant_tiki(
+			origin: OriginFor<T>,
+			dest: <T::Lookup as StaticLookup>::Source,
+			tiki: Tiki,
+		) -> DispatchResult {
+			T::AdminOrigin::ensure_origin(origin)?;
+			let dest_account = T::Lookup::lookup(dest)?;
+
+			// Check if the role can be appointed
+			ensure!(
+				Self::can_grant_role_type(&tiki, &RoleAssignmentType::Appointed),
+				Error::<T>::InvalidRoleAssignmentMethod
+			);
+
+			Self::internal_grant_role(&dest_account, tiki)?;
+			Ok(())
+		}
+
+		/// Admin tarafından belirli bir kullanıcıdan Tiki (rol) alma
+		#[pallet::call_index(1)]
+		#[pallet::weight(<T as crate::pallet::Config>::WeightInfo::revoke_tiki())]
+		pub fn revoke_tiki(
+			origin: OriginFor<T>,
+			target: <T::Lookup as StaticLookup>::Source,
+			tiki: Tiki,
+		) -> DispatchResult {
+			T::AdminOrigin::ensure_origin(origin)?;
+			let target_account = T::Lookup::lookup(target)?;
+
+			Self::internal_revoke_role(&target_account, tiki)?;
+			Ok(())
+		}
+
+		/// Manually mint citizenship NFT (for testing/emergency)
+		#[pallet::call_index(2)]
+		#[pallet::weight(<T as crate::pallet::Config>::WeightInfo::grant_tiki())]
+		pub fn force_mint_citizen_nft(
+			origin: OriginFor<T>,
+			dest: <T::Lookup as StaticLookup>::Source,
+		) -> DispatchResult {
+			T::AdminOrigin::ensure_origin(origin)?;
+			let dest_account = T::Lookup::lookup(dest)?;
+
+			Self::mint_citizen_nft_for_user(&dest_account)?;
+			Ok(())
+		}
+
+		/// Grant role through election system (called from pezpallet-voting)
+		#[pallet::call_index(3)]
+		#[pallet::weight(<T as crate::pallet::Config>::WeightInfo::grant_tiki())]
+		pub fn grant_elected_role(
+			origin: OriginFor<T>,
+			dest: <T::Lookup as StaticLookup>::Source,
+			tiki: Tiki,
+		) -> DispatchResult {
+			T::AdminOrigin::ensure_origin(origin)?; // pezpallet-voting will call with Root origin
+			let dest_account = T::Lookup::lookup(dest)?;
+
+			// Check if the role can be granted through election
+			ensure!(
+				Self::can_grant_role_type(&tiki, &RoleAssignmentType::Elected),
+				Error::<T>::InvalidRoleAssignmentMethod
+			);
+
+			Self::internal_grant_role(&dest_account, tiki)?;
+			Ok(())
+		}
+
+		/// Grant role through exam/test system
+		#[pallet::call_index(4)]
+		#[pallet::weight(<T as crate::pallet::Config>::WeightInfo::grant_tiki())]
+		pub fn grant_earned_role(
+			origin: OriginFor<T>,
+			dest: <T::Lookup as StaticLookup>::Source,
+			tiki: Tiki,
+		) -> DispatchResult {
+			T::AdminOrigin::ensure_origin(origin)?; // For now admin, later exam pallet
+			let dest_account = T::Lookup::lookup(dest)?;
+
+			// Check if the role can be earned
+			ensure!(
+				Self::can_grant_role_type(&tiki, &RoleAssignmentType::Earned),
+				Error::<T>::InvalidRoleAssignmentMethod
+			);
+
+			Self::internal_grant_role(&dest_account, tiki)?;
+			Ok(())
+		}
+
+		/// Apply for citizenship after KYC completion
+		#[pallet::call_index(5)]
+		#[pallet::weight(<T as crate::pallet::Config>::WeightInfo::grant_tiki())]
+		pub fn apply_for_citizenship(origin: OriginFor<T>) -> DispatchResult {
+			let who = ensure_signed(origin)?;
+
+			// Check if user's KYC is approved
+			let kyc_status = pezpallet_identity_kyc::Pallet::<T>::kyc_status_of(&who);
+			ensure!(
+				kyc_status == pezpallet_identity_kyc::types::KycLevel::Approved,
+				Error::<T>::KycNotCompleted
+			);
+
+			// Mint citizenship NFT
+			Self::mint_citizen_nft_for_user(&who)?;
+
+			Ok(())
+		}
+
+		/// Check NFT transfer for transfer blocking system
+		#[pallet::call_index(6)]
+		#[pallet::weight(<T as crate::pallet::Config>::WeightInfo::grant_tiki())]
+		pub fn check_transfer_permission(
+			_origin: OriginFor<T>,
+			collection_id: T::CollectionId,
+			item_id: u32,
+			from: T::AccountId,
+			to: T::AccountId,
+		) -> DispatchResult {
+			// Tiki NFT koleksiyonu ise transfer'e izin verme
+			if collection_id == T::TikiCollectionId::get() {
+				Self::deposit_event(Event::TransferBlocked { collection_id, item_id, from, to });
+				return Err(DispatchError::Other("Citizen NFTs are non-transferable"));
+			}
+			Ok(())
+		}
+	}
+
+	// Pallet's helper functions
+	impl<T: Config> Pallet<T> {
+		/// Checks newly KYC-completed users and mints citizenship NFT
+		fn check_and_mint_citizen_nfts() {
+			// Check all approved users in KYC pallet
+			for (account, kyc_status) in pezpallet_identity_kyc::KycStatuses::<T>::iter() {
+				// Check if KYC is approved
+				if kyc_status == pezpallet_identity_kyc::types::KycLevel::Approved {
+					// Check if citizenship NFT exists
+					if Self::citizen_nft(&account).is_none() {
+						// Mint NFT (log error but continue on failure)
+						if Self::mint_citizen_nft_for_user(&account).is_err() {
+							log::warn!("Failed to mint citizen NFT for account: {:?}", account);
+						}
+					}
+				}
+			}
+		}
+
+		/// Mints citizenship NFT for specific user
+		pub fn mint_citizen_nft_for_user(user: &T::AccountId) -> DispatchResult {
+			// Check if NFT already exists
+			ensure!(Self::citizen_nft(user).is_none(), Error::<T>::CitizenNftAlreadyExists);
+
+			let collection_id = T::TikiCollectionId::get();
+			let next_id_u32 = Self::next_item_id();
+
+			// Mint the NFT - use force_mint in benchmarks to bypass balance/origin requirements
+			#[cfg(feature = "runtime-benchmarks")]
+			pezpallet_nfts::Pallet::<T>::force_mint(
+				T::RuntimeOrigin::from(pezframe_system::RawOrigin::Root),
+				collection_id,
+				next_id_u32,
+				T::Lookup::unlookup(user.clone()),
+				Default::default(),
+			)?;
+
+			#[cfg(not(feature = "runtime-benchmarks"))]
+			pezpallet_nfts::Pallet::<T>::force_mint(
+				T::RuntimeOrigin::from(pezframe_system::RawOrigin::Root),
+				collection_id,
+				next_id_u32,
+				T::Lookup::unlookup(user.clone()),
+				Default::default(),
+			)?;
+
+			// Make NFT non-transferable
+			Self::lock_nft_transfer(&collection_id, &next_id_u32)?;
+
+			// Update storage
+			CitizenNft::<T>::insert(user, next_id_u32);
+			NextItemId::<T>::put(next_id_u32.saturating_add(1));
+
+			// Automatically add Welati role
+			UserTikis::<T>::mutate(user, |tikis| {
+				let _ = tikis.try_push(Tiki::Welati);
+			});
+
+			// Set NFT metadata
+			Self::update_nft_metadata(user)?;
+
+			Self::deposit_event(Event::CitizenNftMinted { who: user.clone(), nft_id: next_id_u32 });
+			Ok(())
+		}
+
+		/// Internal role granting function (to avoid code duplication)
+		pub fn internal_grant_role(dest_account: &T::AccountId, tiki: Tiki) -> DispatchResult {
+			// Check if citizenship NFT exists
+			ensure!(Self::citizen_nft(dest_account).is_some(), Error::<T>::CitizenNftNotFound);
+
+			// If this role is unique (can belong to only one person), check
+			if Self::is_unique_role(&tiki) {
+				ensure!(Self::tiki_holder(tiki).is_none(), Error::<T>::RoleAlreadyTaken);
+			}
+
+			// Check if user already has this role
+			let user_tikis = Self::user_tikis(dest_account);
+			ensure!(!user_tikis.contains(&tiki), Error::<T>::UserAlreadyHasRole);
+
+			// Add to user's Tiki list
+			UserTikis::<T>::try_mutate(dest_account, |tikis| {
+				tikis.try_push(tiki).map_err(|_| Error::<T>::ExceedsMaxRolesPerUser)
+			})?;
+
+			// If unique role, also add to TikiHolder
+			if Self::is_unique_role(&tiki) {
+				TikiHolder::<T>::insert(tiki, dest_account);
+			}
+
+			// Update NFT metadata
+			Self::update_nft_metadata(dest_account)?;
+
+			Self::deposit_event(Event::TikiGranted { who: dest_account.clone(), tiki });
+			Ok(())
+		}
+
+		/// Internal role revocation function
+		pub fn internal_revoke_role(target_account: &T::AccountId, tiki: Tiki) -> DispatchResult {
+			// Check if user has this role
+			let user_tikis = Self::user_tikis(target_account);
+			let _position =
+				user_tikis.iter().position(|&r| r == tiki).ok_or(Error::<T>::RoleNotAssigned)?;
+
+			// Welati role cannot be removed
+			ensure!(tiki != Tiki::Welati, Error::<T>::RoleNotAssigned);
+
+			// Remove from user's Tiki list
+			UserTikis::<T>::mutate(target_account, |tikis| {
+				if let Some(pos) = tikis.iter().position(|&r| r == tiki) {
+					tikis.swap_remove(pos);
+				}
+			});
+
+			// If unique role, also remove from TikiHolder
+			if Self::is_unique_role(&tiki) {
+				TikiHolder::<T>::remove(tiki);
+			}
+
+			// Update NFT metadata
+			Self::update_nft_metadata(target_account)?;
+
+			Self::deposit_event(Event::TikiRevoked { who: target_account.clone(), tiki });
+			Ok(())
+		}
+
+		/// Makes NFT non-transferable
+		fn lock_nft_transfer(collection_id: &T::CollectionId, item_id: &u32) -> DispatchResult {
+			// Mark NFT with lock attribute - use force_set_attribute in benchmarks to bypass
+			// deposits
+			#[cfg(feature = "runtime-benchmarks")]
+			let _ = pezpallet_nfts::Pallet::<T>::force_set_attribute(
+				T::RuntimeOrigin::from(pezframe_system::RawOrigin::Root),
+				None,
+				*collection_id,
+				Some(*item_id),
+				pezpallet_nfts::AttributeNamespace::Pallet,
+				b"locked"
+					.to_vec()
+					.try_into()
+					.map_err(|_| DispatchError::Other("Key too long"))?,
+				b"true"
+					.to_vec()
+					.try_into()
+					.map_err(|_| DispatchError::Other("Value too long"))?,
+			);
+
+			#[cfg(not(feature = "runtime-benchmarks"))]
+			let _ = pezpallet_nfts::Pallet::<T>::set_attribute(
+				T::RuntimeOrigin::from(pezframe_system::RawOrigin::Root),
+				*collection_id,
+				Some(*item_id),
+				pezpallet_nfts::AttributeNamespace::Pallet,
+				b"locked"
+					.to_vec()
+					.try_into()
+					.map_err(|_| DispatchError::Other("Key too long"))?,
+				b"true"
+					.to_vec()
+					.try_into()
+					.map_err(|_| DispatchError::Other("Value too long"))?,
+			);
+
+			Ok(())
+		}
+
+		/// Updates NFT metadata based on user's roles
+		fn update_nft_metadata(user: &T::AccountId) -> DispatchResult {
+			let nft_id_u32 = Self::citizen_nft(user).ok_or(Error::<T>::CitizenNftNotFound)?;
+			let collection_id = T::TikiCollectionId::get();
+			let user_tikis = Self::user_tikis(user);
+
+			let total_score = Self::get_tiki_score(user);
+
+			// Short metadata - only basic information
+			let metadata = format!(
+				r#"{{"citizen":true,"roles":{},"score":{}}}"#,
+				user_tikis.len(),
+				total_score
+			);
+
+			// Set metadata - log error but don't crash
+			if pezpallet_nfts::Pallet::<T>::set_metadata(
+				T::RuntimeOrigin::from(pezframe_system::RawOrigin::Root),
+				collection_id,
+				nft_id_u32,
+				metadata
+					.as_bytes()
+					.to_vec()
+					.try_into()
+					.map_err(|_| DispatchError::Other("Metadata too long"))?,
+			)
+			.is_err()
+			{
+				log::warn!("Failed to set metadata for NFT: {:?}", nft_id_u32);
+			}
+
+			Ok(())
+		}
+
+		/// Checks if a specific role is unique (can belong to only one person)
+		pub fn is_unique_role(tiki: &Tiki) -> bool {
+			matches!(tiki, Tiki::Serok | Tiki::SerokiMeclise | Tiki::Xezinedar | Tiki::Balyoz)
+		}
+
+		/// Returns the assignment type of a specific role
+		pub fn get_role_assignment_type(tiki: &Tiki) -> RoleAssignmentType {
+			match tiki {
+				// Automatic roles
+				Tiki::Welati => RoleAssignmentType::Automatic,
+
+				// Elected roles
+				Tiki::Parlementer | Tiki::SerokiMeclise | Tiki::Serok =>
+					RoleAssignmentType::Elected,
+
+				// Earned roles (automatically given by pezpallet-referral)
+				Tiki::Axa |
+				Tiki::Mamoste |
+				Tiki::Rewsenbîr |
+				Tiki::SerokêKomele |
+				Tiki::ModeratorêCivakê => RoleAssignmentType::Earned,
+
+				// Appointed roles (default)
+				_ => RoleAssignmentType::Appointed,
+			}
+		}
+
+		/// Checks the granting method of a specific role
+		pub fn can_grant_role_type(tiki: &Tiki, assignment_type: &RoleAssignmentType) -> bool {
+			let required_type = Self::get_role_assignment_type(tiki);
+			match (&required_type, assignment_type) {
+				// Automatic roles can only be given by the system
+				(RoleAssignmentType::Automatic, RoleAssignmentType::Automatic) => true,
+				// Appointed roles can be given by admin
+				(RoleAssignmentType::Appointed, RoleAssignmentType::Appointed) => true,
+				// Elected roles can be given by election system
+				(RoleAssignmentType::Elected, RoleAssignmentType::Elected) => true,
+				// Earned roles can be given by exam/test system
+				(RoleAssignmentType::Earned, RoleAssignmentType::Earned) => true,
+				_ => false,
+			}
+		}
+
+		/// KYC sonrası otomatik Welati rolü verme
+		pub fn auto_grant_citizenship(account: &T::AccountId) -> DispatchResult {
+			// KYC kontrolü
+			let kyc_status = pezpallet_identity_kyc::Pallet::<T>::kyc_status_of(account);
+			if kyc_status == pezpallet_identity_kyc::types::KycLevel::Approved {
+				// Vatandaşlık NFT'si yoksa bas
+				if Self::citizen_nft(account).is_none() {
+					Self::mint_citizen_nft_for_user(account)?;
+				}
+			}
+			Ok(())
+		}
+
+		/// Kullanıcının belirli bir Tiki'ye sahip olup olmadığını kontrol eder
+		pub fn has_tiki(who: &T::AccountId, tiki: &Tiki) -> bool {
+			Self::user_tikis(who).contains(tiki)
+		}
+
+		/// Kullanıcının vatandaş olup olmadığını kontrol eder
+		pub fn is_citizen(who: &T::AccountId) -> bool {
+			Self::citizen_nft(who).is_some()
+		}
+	}
+}
+
+/// Diğer paletlerin, bu paletten Tiki puanlarını sorgulaması için kullanılacak trait
+pub trait TikiScoreProvider<AccountId> {
+	fn get_tiki_score(who: &AccountId) -> u32;
+}
+
+/// Diğer paletlerin, Tiki sahipliğini sorgulaması için kullanılacak trait
+pub trait TikiProvider<AccountId> {
+	fn has_tiki(who: &AccountId, tiki: &Tiki) -> bool;
+	fn get_user_tikis(who: &AccountId) -> Vec<Tiki>;
+	fn is_citizen(who: &AccountId) -> bool;
+}
+
+/// Trait implementasyonları
+impl<T: Config> TikiScoreProvider<T::AccountId> for Pallet<T> {
+	fn get_tiki_score(who: &T::AccountId) -> u32 {
+		let tikis = Self::user_tikis(who);
+		tikis.iter().map(Self::get_bonus_for_tiki).sum()
+	}
+}
+
+impl<T: Config> TikiProvider<T::AccountId> for Pallet<T> {
+	fn has_tiki(who: &T::AccountId, tiki: &Tiki) -> bool {
+		Self::has_tiki(who, tiki)
+	}
+
+	fn get_user_tikis(who: &T::AccountId) -> Vec<Tiki> {
+		Self::user_tikis(who).into_inner()
+	}
+
+	fn is_citizen(who: &T::AccountId) -> bool {
+		Self::is_citizen(who)
+	}
+}
+
+// Puanlama mantığını ayrı bir impl bloğunda tutarak kodu daha düzenli hale getiriyoruz.
+impl<T: Config> Pallet<T> {
+	/// Belirli bir Tiki'nin Trust Puanı'na olan katkısını döndürür.
+	pub fn get_bonus_for_tiki(tiki: &Tiki) -> u32 {
+		match tiki {
+			// Anayasa v5.0'da Belirlenen Özel Puanlar
+			Tiki::Axa => 250,
+			Tiki::RêveberêProjeyê => 250,
+			Tiki::ModeratorêCivakê => 200,
+			Tiki::SerokêKomele => 100,
+			Tiki::Mela => 50,
+			Tiki::Feqî => 50,
+
+			// Hiyerarşik Devlet Puanları
+			// Yargı
+			Tiki::EndameDiwane => 175,
+			Tiki::Dadger => 150,
+			Tiki::Dozger => 120,
+			Tiki::Hiquqnas => 75,
+			// Yürütme
+			Tiki::Serok => 200,
+			Tiki::Wezir => 100,
+			Tiki::SerokWeziran => 125,
+			Tiki::WezireDarayiye => 100,
+			Tiki::WezireParez => 100,
+			Tiki::WezireDad => 100,
+			Tiki::WezireBelaw => 100,
+			Tiki::WezireTend => 100,
+			Tiki::WezireAva => 100,
+			Tiki::WezireCand => 100,
+
+			// Yasama
+			Tiki::SerokiMeclise => 150,
+			Tiki::Parlementer => 100,
+
+			// Atanmış Üst Düzey Memurlar
+			Tiki::Xezinedar => 100,
+			Tiki::PisporêEwlehiyaSîber => 100,
+			Tiki::Mufetîs => 90,
+			Tiki::Balyoz => 80,
+			Tiki::Berdevk => 70,
+
+			// Diğer Memurlar ve Uzmanlar
+			Tiki::Mamoste => 70,
+			Tiki::OperatorêTorê => 60,
+			Tiki::Noter => 50,
+			Tiki::Bacgir => 50,
+			Tiki::Perwerdekar => 40,
+			Tiki::Rewsenbîr => 40,
+			Tiki::GerinendeyeCavkaniye => 40,
+			Tiki::GerinendeyeDaneye => 40,
+			Tiki::KalîteKontrolker => 30,
+			Tiki::Navbeynkar => 30,
+			Tiki::Hekem => 30,
+			Tiki::Qeydkar => 25,
+			Tiki::ParêzvaneÇandî => 25,
+			Tiki::Sêwirmend => 20,
+			Tiki::Bazargan => 60, // Yeni eklenen ekonomik rol
+
+			// Temel Vatandaşlık ve Diğerleri
+			Tiki::Welati => 10,
+			// Yukarıdaki listede olmayan diğer tüm roller 5 puan alır.
+			_ => 5,
+		}
+	}
+}
+// CitizenNftProvider trait implementation for pezpallet-identity-kyc integration
+impl<T: Config> pezpallet_identity_kyc::types::CitizenNftProvider<T::AccountId> for Pallet<T> {
+	fn mint_citizen_nft(who: &T::AccountId) -> pezsp_runtime::DispatchResult {
+		Self::mint_citizen_nft_for_user(who)
+	}
+
+	fn mint_citizen_nft_confirmed(who: &T::AccountId) -> pezsp_runtime::DispatchResult {
+		// For self-confirmation, we use the same mint function with force_mint
+		Self::mint_citizen_nft_for_user(who)
+	}
+
+	fn burn_citizen_nft(who: &T::AccountId) -> pezsp_runtime::DispatchResult {
+		use pezframe_support::traits::Get;
+		// Get the citizen NFT item ID
+		let item_id = Self::citizen_nft(who).ok_or(Error::<T>::CitizenNftNotFound)?;
+		let collection_id = T::TikiCollectionId::get();
+
+		// Burn the NFT using pezpallet_nfts burn function
+		pezpallet_nfts::Pallet::<T>::burn(
+			T::RuntimeOrigin::from(pezframe_system::RawOrigin::Signed(who.clone())),
+			collection_id,
+			item_id,
+		)?;
+
+		// Remove from our storage
+		CitizenNft::<T>::remove(who);
+
+		Ok(())
+	}
+}