feat: Rebrand Polkadot/Substrate references to PezkuwiChain

This commit systematically rebrands various references from Parity Technologies'
Polkadot/Substrate ecosystem to PezkuwiChain within the kurdistan-sdk.

Key changes include:
- Updated external repository URLs (zombienet-sdk, parity-db, parity-scale-codec, wasm-instrument) to point to pezkuwichain forks.
- Modified internal documentation and code comments to reflect PezkuwiChain naming and structure.
- Replaced direct references to  with  or specific paths within the  for XCM, Pezkuwi, and other modules.
- Cleaned up deprecated  issue and PR references in various  and  files, particularly in  and  modules.
- Adjusted image and logo URLs in documentation to point to PezkuwiChain assets.
- Removed or rephrased comments related to external Polkadot/Substrate PRs and issues.

This is a significant step towards fully customizing the SDK for the PezkuwiChain ecosystem.

bizinikiwi/pezframe/nft-fractionalization/src/benchmarking.rs

@@ -0,0 +1,149 @@
+// This file is part of Bizinikiwi.
+
+// Copyright (C) Parity Technologies (UK) Ltd.
+// SPDX-License-Identifier: Apache-2.0
+
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// 	http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+//! Nft fractionalization pallet benchmarking.
+
+#![cfg(feature = "runtime-benchmarks")]
+
+use super::*;
+use frame::benchmarking::prelude::*;
+
+use frame::deps::pezframe_support::assert_ok;
+use fungible::{Inspect as InspectFungible, Mutate as MutateFungible};
+use nonfungibles_v2::{Create, Mutate};
+
+use pezframe_system::RawOrigin as SystemOrigin;
+use pezpallet_nfts::{CollectionConfig, CollectionSettings, ItemConfig, MintSettings};
+
+use crate::Pallet as NftFractionalization;
+
+type BalanceOf<T> =
+	<<T as Config>::Currency as InspectFungible<<T as SystemConfig>::AccountId>>::Balance;
+
+type CollectionConfigOf<T> =
+	CollectionConfig<BalanceOf<T>, BlockNumberFor<T>, <T as Config>::NftCollectionId>;
+
+fn default_collection_config<T: Config>() -> CollectionConfigOf<T>
+where
+	T::Currency: InspectFungible<T::AccountId>,
+{
+	CollectionConfig {
+		settings: CollectionSettings::all_enabled(),
+		max_supply: None,
+		mint_settings: MintSettings::default(),
+	}
+}
+
+fn mint_nft<T: Config>(nft_id: T::NftId) -> (T::AccountId, AccountIdLookupOf<T>)
+where
+	T::Nfts: Create<T::AccountId, CollectionConfig<BalanceOf<T>, BlockNumberFor<T>, T::NftCollectionId>>
+		+ Mutate<T::AccountId, ItemConfig>,
+{
+	let caller: T::AccountId = whitelisted_caller();
+	let caller_lookup = T::Lookup::unlookup(caller.clone());
+	let ed = T::Currency::minimum_balance();
+	let multiplier = BalanceOf::<T>::from(100u8);
+	T::Currency::set_balance(&caller, ed * multiplier + T::Deposit::get() * multiplier);
+
+	assert_ok!(T::Nfts::create_collection(&caller, &caller, &default_collection_config::<T>()));
+	let collection = T::BenchmarkHelper::collection(0);
+	assert_ok!(T::Nfts::mint_into(&collection, &nft_id, &caller, &ItemConfig::default(), true));
+	(caller, caller_lookup)
+}
+
+fn assert_last_event<T: Config>(generic_event: <T as Config>::RuntimeEvent) {
+	let events = pezframe_system::Pallet::<T>::events();
+	let system_event: <T as pezframe_system::Config>::RuntimeEvent = generic_event.into();
+	// compare to the last event record
+	let pezframe_system::EventRecord { event, .. } = &events[events.len() - 1];
+	assert_eq!(event, &system_event);
+}
+
+#[benchmarks(
+	where
+		T::Nfts:
+			Create<
+				T::AccountId,
+				CollectionConfig<BalanceOf<T>,
+				pezframe_system::pezpallet_prelude::BlockNumberFor::<T>,
+				T::NftCollectionId>
+			>
+			+ Mutate<T::AccountId, ItemConfig>,
+)]
+mod benchmarks {
+	use super::*;
+
+	#[benchmark]
+	fn fractionalize() {
+		let asset = T::BenchmarkHelper::asset(0);
+		let collection = T::BenchmarkHelper::collection(0);
+		let nft = T::BenchmarkHelper::nft(0);
+		let (caller, caller_lookup) = mint_nft::<T>(nft);
+
+		#[extrinsic_call]
+		_(
+			SystemOrigin::Signed(caller.clone()),
+			collection,
+			nft,
+			asset.clone(),
+			caller_lookup,
+			1000u32.into(),
+		);
+
+		assert_last_event::<T>(
+			Event::NftFractionalized {
+				nft_collection: collection,
+				nft,
+				fractions: 1000u32.into(),
+				asset,
+				beneficiary: caller,
+			}
+			.into(),
+		);
+	}
+
+	#[benchmark]
+	fn unify() {
+		let asset = T::BenchmarkHelper::asset(0);
+		let collection = T::BenchmarkHelper::collection(0);
+		let nft = T::BenchmarkHelper::nft(0);
+		let (caller, caller_lookup) = mint_nft::<T>(nft);
+
+		assert_ok!(NftFractionalization::<T>::fractionalize(
+			SystemOrigin::Signed(caller.clone()).into(),
+			collection,
+			nft,
+			asset.clone(),
+			caller_lookup.clone(),
+			1000u32.into(),
+		));
+
+		#[extrinsic_call]
+		_(SystemOrigin::Signed(caller.clone()), collection, nft, asset.clone(), caller_lookup);
+
+		assert_last_event::<T>(
+			Event::NftUnified { nft_collection: collection, nft, asset, beneficiary: caller }
+				.into(),
+		);
+	}
+
+	impl_benchmark_test_suite!(
+		NftFractionalization,
+		crate::mock::new_test_ext(),
+		crate::mock::Test
+	);
+}

bizinikiwi/pezframe/nft-fractionalization/src/lib.rs

@@ -0,0 +1,402 @@
+// This file is part of Bizinikiwi.
+
+// Copyright (C) Parity Technologies (UK) Ltd.
+// SPDX-License-Identifier: Apache-2.0
+
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// 	http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+//! # NFT Fractionalization Pallet
+//!
+//! This pallet provides the basic functionality that should allow users
+//! to leverage partial ownership, transfers, and sales, of illiquid assets,
+//! whether real-world assets represented by their digital twins, or NFTs,
+//! or original NFTs.
+//!
+//! The functionality allows a user to lock an NFT they own, create a new
+//! fungible asset, and mint a set amount of tokens (`fractions`).
+//!
+//! It also allows the user to burn 100% of the asset and to unlock the NFT
+//! into their account.
+//!
+//! ### Functions
+//!
+//! * `fractionalize`: Lock the NFT and create and mint a new fungible asset.
+//! * `unify`: Return 100% of the asset and unlock the NFT.
+
+// Ensure we're `no_std` when compiling for Wasm.
+#![cfg_attr(not(feature = "std"), no_std)]
+
+mod types;
+
+#[cfg(feature = "runtime-benchmarks")]
+mod benchmarking;
+#[cfg(test)]
+pub mod mock;
+#[cfg(test)]
+mod tests;
+
+pub mod weights;
+
+use frame::prelude::*;
+use pezframe_system::Config as SystemConfig;
+pub use pallet::*;
+pub use types::*;
+pub use weights::WeightInfo;
+
+#[frame::pallet]
+pub mod pallet {
+	use super::*;
+	use core::fmt::Display;
+	use fungible::{
+		hold::Mutate as HoldMutateFungible, Inspect as InspectFungible, Mutate as MutateFungible,
+	};
+	use fungibles::{
+		metadata::{MetadataDeposit, Mutate as MutateMetadata},
+		Create, Destroy, Inspect, Mutate,
+	};
+	use nonfungibles_v2::{Inspect as NonFungiblesInspect, Transfer};
+	use scale_info::prelude::{format, string::String};
+
+	use tokens::{
+		AssetId, Balance as AssetBalance,
+		Fortitude::Polite,
+		Precision::{BestEffort, Exact},
+		Preservation::{Expendable, Preserve},
+	};
+	#[pallet::pallet]
+	pub struct Pallet<T>(_);
+
+	#[pallet::config]
+	pub trait Config: pezframe_system::Config {
+		/// The overarching event type.
+		#[allow(deprecated)]
+		type RuntimeEvent: From<Event<Self>> + IsType<<Self as pezframe_system::Config>::RuntimeEvent>;
+
+		/// The currency mechanism, used for paying for deposits.
+		type Currency: InspectFungible<Self::AccountId>
+			+ MutateFungible<Self::AccountId>
+			+ HoldMutateFungible<Self::AccountId, Reason = Self::RuntimeHoldReason>;
+
+		/// Overarching hold reason.
+		type RuntimeHoldReason: From<HoldReason>;
+
+		/// The deposit paid by the user locking an NFT. The deposit is returned to the original NFT
+		/// owner when the asset is unified and the NFT is unlocked.
+		#[pallet::constant]
+		type Deposit: Get<DepositOf<Self>>;
+
+		/// Identifier for the collection of NFT.
+		type NftCollectionId: Member + Parameter + MaxEncodedLen + Copy + Display;
+
+		/// The type used to identify an NFT within a collection.
+		type NftId: Member + Parameter + MaxEncodedLen + Copy + Display;
+
+		/// The type used to describe the amount of fractions converted into assets.
+		type AssetBalance: AssetBalance;
+
+		/// The type used to identify the assets created during fractionalization.
+		type AssetId: AssetId;
+
+		/// Registry for the minted assets.
+		type Assets: Inspect<Self::AccountId, AssetId = Self::AssetId, Balance = Self::AssetBalance>
+			+ Create<Self::AccountId>
+			+ Destroy<Self::AccountId>
+			+ Mutate<Self::AccountId>
+			+ MutateMetadata<Self::AccountId>
+			+ MetadataDeposit<DepositOf<Self>>;
+
+		/// Registry for minted NFTs.
+		type Nfts: NonFungiblesInspect<
+				Self::AccountId,
+				ItemId = Self::NftId,
+				CollectionId = Self::NftCollectionId,
+			> + Transfer<Self::AccountId>;
+
+		/// The pallet's id, used for deriving its sovereign account ID.
+		#[pallet::constant]
+		type PalletId: Get<PalletId>;
+
+		/// The newly created asset's symbol.
+		#[pallet::constant]
+		type NewAssetSymbol: Get<BoundedVec<u8, Self::StringLimit>>;
+
+		/// The newly created asset's name.
+		#[pallet::constant]
+		type NewAssetName: Get<BoundedVec<u8, Self::StringLimit>>;
+
+		/// The maximum length of a name or symbol stored on-chain.
+		#[pallet::constant]
+		type StringLimit: Get<u32>;
+
+		/// A set of helper functions for benchmarking.
+		#[cfg(feature = "runtime-benchmarks")]
+		type BenchmarkHelper: BenchmarkHelper<Self::AssetId, Self::NftCollectionId, Self::NftId>;
+
+		/// Weight information for extrinsics in this pallet.
+		type WeightInfo: WeightInfo;
+	}
+
+	/// Keeps track of the corresponding NFT ID, asset ID and amount minted.
+	#[pallet::storage]
+	pub type NftToAsset<T: Config> = StorageMap<
+		_,
+		Blake2_128Concat,
+		(T::NftCollectionId, T::NftId),
+		Details<AssetIdOf<T>, AssetBalanceOf<T>, DepositOf<T>, T::AccountId>,
+		OptionQuery,
+	>;
+
+	#[pallet::event]
+	#[pallet::generate_deposit(pub(super) fn deposit_event)]
+	pub enum Event<T: Config> {
+		/// An NFT was successfully fractionalized.
+		NftFractionalized {
+			nft_collection: T::NftCollectionId,
+			nft: T::NftId,
+			fractions: AssetBalanceOf<T>,
+			asset: AssetIdOf<T>,
+			beneficiary: T::AccountId,
+		},
+		/// An NFT was successfully returned back.
+		NftUnified {
+			nft_collection: T::NftCollectionId,
+			nft: T::NftId,
+			asset: AssetIdOf<T>,
+			beneficiary: T::AccountId,
+		},
+	}
+
+	#[pallet::error]
+	pub enum Error<T> {
+		/// Asset ID does not correspond to locked NFT.
+		IncorrectAssetId,
+		/// The signing account has no permission to do the operation.
+		NoPermission,
+		/// NFT doesn't exist.
+		NftNotFound,
+		/// NFT has not yet been fractionalised.
+		NftNotFractionalized,
+	}
+
+	/// A reason for the pallet placing a hold on funds.
+	#[pallet::composite_enum]
+	pub enum HoldReason {
+		/// Reserved for a fractionalized NFT.
+		#[codec(index = 0)]
+		Fractionalized,
+	}
+
+	#[pallet::call]
+	impl<T: Config> Pallet<T> {
+		/// Lock the NFT and mint a new fungible asset.
+		///
+		/// The dispatch origin for this call must be Signed.
+		/// The origin must be the owner of the NFT they are trying to lock.
+		///
+		/// `Deposit` funds of sender are reserved.
+		///
+		/// - `nft_collection_id`: The ID used to identify the collection of the NFT.
+		/// Is used within the context of `pezpallet_nfts`.
+		/// - `nft_id`: The ID used to identify the NFT within the given collection.
+		/// Is used within the context of `pezpallet_nfts`.
+		/// - `asset_id`: The ID of the new asset. It must not exist.
+		/// Is used within the context of `pezpallet_assets`.
+		/// - `beneficiary`: The account that will receive the newly created asset.
+		/// - `fractions`: The total issuance of the newly created asset class.
+		///
+		/// Emits `NftFractionalized` event when successful.
+		#[pallet::call_index(0)]
+		#[pallet::weight(T::WeightInfo::fractionalize())]
+		pub fn fractionalize(
+			origin: OriginFor<T>,
+			nft_collection_id: T::NftCollectionId,
+			nft_id: T::NftId,
+			asset_id: AssetIdOf<T>,
+			beneficiary: AccountIdLookupOf<T>,
+			fractions: AssetBalanceOf<T>,
+		) -> DispatchResult {
+			let who = ensure_signed(origin)?;
+			let beneficiary = T::Lookup::lookup(beneficiary)?;
+
+			let nft_owner =
+				T::Nfts::owner(&nft_collection_id, &nft_id).ok_or(Error::<T>::NftNotFound)?;
+			ensure!(nft_owner == who, Error::<T>::NoPermission);
+
+			let pezpallet_account = Self::get_pallet_account();
+			let deposit = T::Deposit::get();
+			T::Currency::hold(&HoldReason::Fractionalized.into(), &nft_owner, deposit)?;
+			Self::do_lock_nft(nft_collection_id, nft_id)?;
+			Self::do_create_asset(asset_id.clone(), pezpallet_account.clone())?;
+			Self::do_mint_asset(asset_id.clone(), &beneficiary, fractions)?;
+			Self::do_set_metadata(
+				asset_id.clone(),
+				&who,
+				&pezpallet_account,
+				&nft_collection_id,
+				&nft_id,
+			)?;
+
+			NftToAsset::<T>::insert(
+				(nft_collection_id, nft_id),
+				Details { asset: asset_id.clone(), fractions, asset_creator: nft_owner, deposit },
+			);
+
+			Self::deposit_event(Event::NftFractionalized {
+				nft_collection: nft_collection_id,
+				nft: nft_id,
+				fractions,
+				asset: asset_id,
+				beneficiary,
+			});
+
+			Ok(())
+		}
+
+		/// Burn the total issuance of the fungible asset and return (unlock) the locked NFT.
+		///
+		/// The dispatch origin for this call must be Signed.
+		///
+		/// `Deposit` funds will be returned to `asset_creator`.
+		///
+		/// - `nft_collection_id`: The ID used to identify the collection of the NFT.
+		/// Is used within the context of `pezpallet_nfts`.
+		/// - `nft_id`: The ID used to identify the NFT within the given collection.
+		/// Is used within the context of `pezpallet_nfts`.
+		/// - `asset_id`: The ID of the asset being returned and destroyed. Must match
+		/// the original ID of the created asset, corresponding to the NFT.
+		/// Is used within the context of `pezpallet_assets`.
+		/// - `beneficiary`: The account that will receive the unified NFT.
+		///
+		/// Emits `NftUnified` event when successful.
+		#[pallet::call_index(1)]
+		#[pallet::weight(T::WeightInfo::unify())]
+		pub fn unify(
+			origin: OriginFor<T>,
+			nft_collection_id: T::NftCollectionId,
+			nft_id: T::NftId,
+			asset_id: AssetIdOf<T>,
+			beneficiary: AccountIdLookupOf<T>,
+		) -> DispatchResult {
+			let who = ensure_signed(origin)?;
+			let beneficiary = T::Lookup::lookup(beneficiary)?;
+
+			NftToAsset::<T>::try_mutate_exists((nft_collection_id, nft_id), |maybe_details| {
+				let details = maybe_details.take().ok_or(Error::<T>::NftNotFractionalized)?;
+				ensure!(details.asset == asset_id, Error::<T>::IncorrectAssetId);
+
+				let deposit = details.deposit;
+				let asset_creator = details.asset_creator;
+				Self::do_burn_asset(asset_id.clone(), &who, details.fractions)?;
+				Self::do_unlock_nft(nft_collection_id, nft_id, &beneficiary)?;
+				T::Currency::release(
+					&HoldReason::Fractionalized.into(),
+					&asset_creator,
+					deposit,
+					BestEffort,
+				)?;
+
+				Self::deposit_event(Event::NftUnified {
+					nft_collection: nft_collection_id,
+					nft: nft_id,
+					asset: asset_id,
+					beneficiary,
+				});
+
+				Ok(())
+			})
+		}
+	}
+
+	impl<T: Config> Pallet<T> {
+		/// The account ID of the pallet.
+		///
+		/// This actually does computation. If you need to keep using it, then make sure you cache
+		/// the value and only call this once.
+		fn get_pallet_account() -> T::AccountId {
+			T::PalletId::get().into_account_truncating()
+		}
+
+		/// Keeps track of the corresponding NFT ID, asset ID and amount minted.
+		pub fn nft_to_asset(
+			key: (T::NftCollectionId, T::NftId),
+		) -> Option<Details<AssetIdOf<T>, AssetBalanceOf<T>, DepositOf<T>, T::AccountId>> {
+			NftToAsset::<T>::get(key)
+		}
+
+		/// Prevent further transferring of NFT.
+		fn do_lock_nft(nft_collection_id: T::NftCollectionId, nft_id: T::NftId) -> DispatchResult {
+			T::Nfts::disable_transfer(&nft_collection_id, &nft_id)
+		}
+
+		/// Remove the transfer lock and transfer the NFT to the account returning the tokens.
+		fn do_unlock_nft(
+			nft_collection_id: T::NftCollectionId,
+			nft_id: T::NftId,
+			account: &T::AccountId,
+		) -> DispatchResult {
+			T::Nfts::enable_transfer(&nft_collection_id, &nft_id)?;
+			T::Nfts::transfer(&nft_collection_id, &nft_id, account)
+		}
+
+		/// Create the new asset.
+		fn do_create_asset(asset_id: AssetIdOf<T>, admin: T::AccountId) -> DispatchResult {
+			T::Assets::create(asset_id, admin, false, One::one())
+		}
+
+		/// Mint the `amount` of tokens with `asset_id` into the beneficiary's account.
+		fn do_mint_asset(
+			asset_id: AssetIdOf<T>,
+			beneficiary: &T::AccountId,
+			amount: AssetBalanceOf<T>,
+		) -> DispatchResult {
+			T::Assets::mint_into(asset_id, beneficiary, amount)?;
+			Ok(())
+		}
+
+		/// Burn tokens from the account.
+		fn do_burn_asset(
+			asset_id: AssetIdOf<T>,
+			account: &T::AccountId,
+			amount: AssetBalanceOf<T>,
+		) -> DispatchResult {
+			T::Assets::burn_from(asset_id.clone(), account, amount, Expendable, Exact, Polite)?;
+			T::Assets::start_destroy(asset_id, None)
+		}
+
+		/// Set the metadata for the newly created asset.
+		fn do_set_metadata(
+			asset_id: AssetIdOf<T>,
+			depositor: &T::AccountId,
+			pezpallet_account: &T::AccountId,
+			nft_collection_id: &T::NftCollectionId,
+			nft_id: &T::NftId,
+		) -> DispatchResult {
+			let name = format!(
+				"{} {nft_collection_id}-{nft_id}",
+				String::from_utf8_lossy(&T::NewAssetName::get())
+			);
+			let symbol: &[u8] = &T::NewAssetSymbol::get();
+			let existential_deposit = T::Currency::minimum_balance();
+			let pezpallet_account_balance = T::Currency::balance(&pezpallet_account);
+
+			if pezpallet_account_balance < existential_deposit {
+				T::Currency::transfer(&depositor, &pezpallet_account, existential_deposit, Preserve)?;
+			}
+			let metadata_deposit = T::Assets::calc_metadata_deposit(name.as_bytes(), symbol);
+			if !metadata_deposit.is_zero() {
+				T::Currency::transfer(&depositor, &pezpallet_account, metadata_deposit, Preserve)?;
+			}
+			T::Assets::set(asset_id, &pezpallet_account, name.into(), symbol.into(), 0)
+		}
+	}
+}

bizinikiwi/pezframe/nft-fractionalization/src/mock.rs

@@ -0,0 +1,151 @@
+// This file is part of Bizinikiwi.
+
+// Copyright (C) Parity Technologies (UK) Ltd.
+// SPDX-License-Identifier: Apache-2.0
+
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// 	http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+//! Test environment for Nft fractionalization pallet.
+
+use super::*;
+use crate as pezpallet_nft_fractionalization;
+
+use frame::{deps::pezsp_runtime::MultiSignature, testing_prelude::*, traits::Verify};
+use pezpallet_nfts::PalletFeatures;
+
+type Block = MockBlock<Test>;
+type Signature = MultiSignature;
+type AccountPublic = <Signature as Verify>::Signer;
+type AccountId = <AccountPublic as IdentifyAccount>::AccountId;
+
+// Configure a mock runtime to test the pallet.
+construct_runtime!(
+	pub enum Test
+	{
+		System: pezframe_system,
+		NftFractionalization: pezpallet_nft_fractionalization,
+		Assets: pezpallet_assets,
+		Balances: pezpallet_balances,
+		Nfts: pezpallet_nfts,
+	}
+);
+
+#[derive_impl(pezframe_system::config_preludes::TestDefaultConfig)]
+impl pezframe_system::Config for Test {
+	type AccountId = AccountId;
+	type Lookup = IdentityLookup<Self::AccountId>;
+	type Block = Block;
+	type AccountData = pezpallet_balances::AccountData<u64>;
+}
+
+#[derive_impl(pezpallet_balances::config_preludes::TestDefaultConfig)]
+impl pezpallet_balances::Config for Test {
+	type AccountStore = System;
+}
+
+impl pezpallet_assets::Config for Test {
+	type RuntimeEvent = RuntimeEvent;
+	type Balance = u64;
+	type RemoveItemsLimit = ConstU32<1000>;
+	type AssetId = u32;
+	type AssetIdParameter = u32;
+	type ReserveData = ();
+	type Currency = Balances;
+	type CreateOrigin = AsEnsureOriginWithArg<EnsureSigned<Self::AccountId>>;
+	type ForceOrigin = pezframe_system::EnsureRoot<Self::AccountId>;
+	type AssetDeposit = ConstU64<1>;
+	type AssetAccountDeposit = ConstU64<10>;
+	type MetadataDepositBase = ConstU64<1>;
+	type MetadataDepositPerByte = ConstU64<1>;
+	type ApprovalDeposit = ConstU64<1>;
+	type StringLimit = ConstU32<50>;
+	type Holder = ();
+	type Freezer = ();
+	type Extra = ();
+	type CallbackHandle = ();
+	type WeightInfo = ();
+	pezpallet_assets::runtime_benchmarks_enabled! {
+		type BenchmarkHelper = ();
+	}
+}
+
+parameter_types! {
+	pub storage Features: PalletFeatures = PalletFeatures::all_enabled();
+}
+
+impl pezpallet_nfts::Config for Test {
+	type RuntimeEvent = RuntimeEvent;
+	type CollectionId = u32;
+	type ItemId = u32;
+	type Currency = Balances;
+	type CreateOrigin = AsEnsureOriginWithArg<pezframe_system::EnsureSigned<Self::AccountId>>;
+	type ForceOrigin = pezframe_system::EnsureRoot<Self::AccountId>;
+	type Locker = ();
+	type CollectionDeposit = ConstU64<2>;
+	type ItemDeposit = ConstU64<1>;
+	type MetadataDepositBase = ConstU64<1>;
+	type AttributeDepositBase = ConstU64<1>;
+	type DepositPerByte = ConstU64<1>;
+	type StringLimit = ConstU32<50>;
+	type KeyLimit = ConstU32<50>;
+	type ValueLimit = ConstU32<50>;
+	type ApprovalsLimit = ConstU32<10>;
+	type ItemAttributesApprovalsLimit = ConstU32<2>;
+	type MaxTips = ConstU32<10>;
+	type MaxDeadlineDuration = ConstU64<10000>;
+	type MaxAttributesPerCall = ConstU32<2>;
+	type Features = Features;
+	type OffchainSignature = Signature;
+	type OffchainPublic = AccountPublic;
+	type WeightInfo = ();
+	type BlockNumberProvider = pezframe_system::Pallet<Test>;
+	pezpallet_nfts::runtime_benchmarks_enabled! {
+		type Helper = ();
+	}
+}
+
+parameter_types! {
+	pub const StringLimit: u32 = 50;
+	pub const NftFractionalizationPalletId: PalletId = PalletId(*b"fraction");
+	pub NewAssetSymbol: BoundedVec<u8, StringLimit> = (*b"FRAC").to_vec().try_into().unwrap();
+	pub NewAssetName: BoundedVec<u8, StringLimit> = (*b"Frac").to_vec().try_into().unwrap();
+}
+
+impl Config for Test {
+	type RuntimeEvent = RuntimeEvent;
+	type Deposit = ConstU64<1>;
+	type Currency = Balances;
+	type NewAssetSymbol = NewAssetSymbol;
+	type NewAssetName = NewAssetName;
+	type NftCollectionId = <Self as pezpallet_nfts::Config>::CollectionId;
+	type NftId = <Self as pezpallet_nfts::Config>::ItemId;
+	type AssetBalance = <Self as pezpallet_balances::Config>::Balance;
+	type AssetId = <Self as pezpallet_assets::Config>::AssetId;
+	type Assets = Assets;
+	type Nfts = Nfts;
+	type PalletId = NftFractionalizationPalletId;
+	type WeightInfo = ();
+	type StringLimit = StringLimit;
+	#[cfg(feature = "runtime-benchmarks")]
+	type BenchmarkHelper = ();
+	type RuntimeHoldReason = RuntimeHoldReason;
+}
+
+// Build genesis storage according to the mock runtime.
+pub(crate) fn new_test_ext() -> TestExternalities {
+	let t = pezframe_system::GenesisConfig::<Test>::default().build_storage().unwrap();
+
+	let mut ext = TestExternalities::new(t);
+	ext.execute_with(|| System::set_block_number(1));
+	ext
+}

bizinikiwi/pezframe/nft-fractionalization/src/tests.rs

@@ -0,0 +1,309 @@
+// This file is part of Bizinikiwi.
+
+// Copyright (C) Parity Technologies (UK) Ltd.
+// SPDX-License-Identifier: Apache-2.0
+
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// 	http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+//! Tests for Nft fractionalization pallet.
+
+use crate::{mock::*, *};
+
+use frame::{deps::pezsp_runtime::ModuleError, testing_prelude::*};
+use fungible::{hold::Inspect as InspectHold, Mutate as MutateFungible};
+use fungibles::{metadata::Inspect, InspectEnumerable};
+use TokenError::FundsUnavailable;
+
+use pezpallet_nfts::CollectionConfig;
+
+fn assets() -> Vec<u32> {
+	let mut s: Vec<_> = <<Test as Config>::Assets>::asset_ids().collect();
+	s.sort();
+	s
+}
+
+fn events() -> Vec<Event<Test>> {
+	let result = System::events()
+		.into_iter()
+		.map(|r| r.event)
+		.filter_map(|e| {
+			if let mock::RuntimeEvent::NftFractionalization(inner) = e {
+				Some(inner)
+			} else {
+				None
+			}
+		})
+		.collect();
+
+	System::reset_events();
+
+	result
+}
+
+type AccountIdOf<Test> = <Test as pezframe_system::Config>::AccountId;
+
+fn account(id: u8) -> AccountIdOf<Test> {
+	[id; 32].into()
+}
+
+#[test]
+fn fractionalize_should_work() {
+	new_test_ext().execute_with(|| {
+		let nft_collection_id = 0;
+		let nft_id = 0;
+		let asset_id = 0;
+		let fractions = 1000;
+
+		Balances::set_balance(&account(1), 100);
+		Balances::set_balance(&account(2), 100);
+
+		assert_ok!(Nfts::force_create(
+			RuntimeOrigin::root(),
+			account(1),
+			CollectionConfig::default(),
+		));
+		assert_ok!(Nfts::mint(
+			RuntimeOrigin::signed(account(1)),
+			nft_collection_id,
+			nft_id,
+			account(1),
+			None,
+		));
+
+		assert_ok!(NftFractionalization::fractionalize(
+			RuntimeOrigin::signed(account(1)),
+			nft_collection_id,
+			nft_id,
+			asset_id,
+			account(2),
+			fractions,
+		));
+		assert_eq!(assets(), vec![asset_id]);
+		assert_eq!(Assets::balance(asset_id, account(2)), fractions);
+		assert_eq!(Balances::total_balance_on_hold(&account(1)), 2);
+		assert_eq!(
+			String::from_utf8(
+				<Assets as Inspect<<Test as pezframe_system::Config>::AccountId>>::name(0)
+			)
+			.unwrap(),
+			"Frac 0-0"
+		);
+		assert_eq!(String::from_utf8(Assets::symbol(0)).unwrap(), "FRAC");
+		assert_eq!(Nfts::owner(nft_collection_id, nft_id), Some(account(1)));
+		assert_noop!(
+			Nfts::transfer(
+				RuntimeOrigin::signed(account(1)),
+				nft_collection_id,
+				nft_id,
+				account(2),
+			),
+			DispatchError::Module(ModuleError {
+				index: 4,
+				error: [12, 0, 0, 0],
+				message: Some("ItemLocked")
+			})
+		);
+
+		let details = NftToAsset::<Test>::get((&nft_collection_id, &nft_id)).unwrap();
+		assert_eq!(details.asset, asset_id);
+		assert_eq!(details.fractions, fractions);
+
+		assert!(events().contains(&Event::<Test>::NftFractionalized {
+			nft_collection: nft_collection_id,
+			nft: nft_id,
+			fractions,
+			asset: asset_id,
+			beneficiary: account(2),
+		}));
+
+		// owner can't burn an already fractionalized NFT
+		assert_noop!(
+			Nfts::burn(RuntimeOrigin::signed(account(1)), nft_collection_id, nft_id),
+			DispatchError::Module(ModuleError {
+				index: 4,
+				error: [12, 0, 0, 0],
+				message: Some("ItemLocked")
+			})
+		);
+
+		// can't fractionalize twice
+		assert_noop!(
+			NftFractionalization::fractionalize(
+				RuntimeOrigin::signed(account(1)),
+				nft_collection_id,
+				nft_id,
+				asset_id + 1,
+				account(2),
+				fractions,
+			),
+			DispatchError::Module(ModuleError {
+				index: 4,
+				error: [12, 0, 0, 0],
+				message: Some("ItemLocked")
+			})
+		);
+
+		let nft_id = nft_id + 1;
+		assert_noop!(
+			NftFractionalization::fractionalize(
+				RuntimeOrigin::signed(account(1)),
+				nft_collection_id,
+				nft_id,
+				asset_id,
+				account(2),
+				fractions,
+			),
+			Error::<Test>::NftNotFound
+		);
+
+		assert_ok!(Nfts::mint(
+			RuntimeOrigin::signed(account(1)),
+			nft_collection_id,
+			nft_id,
+			account(2),
+			None
+		));
+		assert_noop!(
+			NftFractionalization::fractionalize(
+				RuntimeOrigin::signed(account(1)),
+				nft_collection_id,
+				nft_id,
+				asset_id,
+				account(2),
+				fractions,
+			),
+			Error::<Test>::NoPermission
+		);
+	});
+}
+
+#[test]
+fn unify_should_work() {
+	new_test_ext().execute_with(|| {
+		let nft_collection_id = 0;
+		let nft_id = 0;
+		let asset_id = 0;
+		let fractions = 1000;
+
+		Balances::set_balance(&account(1), 100);
+		Balances::set_balance(&account(2), 100);
+
+		assert_ok!(Nfts::force_create(
+			RuntimeOrigin::root(),
+			account(1),
+			CollectionConfig::default(),
+		));
+		assert_ok!(Nfts::mint(
+			RuntimeOrigin::signed(account(1)),
+			nft_collection_id,
+			nft_id,
+			account(1),
+			None,
+		));
+		assert_ok!(NftFractionalization::fractionalize(
+			RuntimeOrigin::signed(account(1)),
+			nft_collection_id,
+			nft_id,
+			asset_id,
+			account(2),
+			fractions,
+		));
+
+		assert_noop!(
+			NftFractionalization::unify(
+				RuntimeOrigin::signed(account(2)),
+				nft_collection_id + 1,
+				nft_id,
+				asset_id,
+				account(1),
+			),
+			Error::<Test>::NftNotFractionalized
+		);
+		assert_noop!(
+			NftFractionalization::unify(
+				RuntimeOrigin::signed(account(2)),
+				nft_collection_id,
+				nft_id,
+				asset_id + 1,
+				account(1),
+			),
+			Error::<Test>::IncorrectAssetId
+		);
+
+		// can't unify the asset a user doesn't hold
+		assert_noop!(
+			NftFractionalization::unify(
+				RuntimeOrigin::signed(account(1)),
+				nft_collection_id,
+				nft_id,
+				asset_id,
+				account(1),
+			),
+			DispatchError::Token(FundsUnavailable)
+		);
+
+		assert_ok!(NftFractionalization::unify(
+			RuntimeOrigin::signed(account(2)),
+			nft_collection_id,
+			nft_id,
+			asset_id,
+			account(1),
+		));
+
+		assert_eq!(Assets::balance(asset_id, account(2)), 0);
+		assert_eq!(Balances::reserved_balance(&account(1)), 1);
+		assert_eq!(Nfts::owner(nft_collection_id, nft_id), Some(account(1)));
+		assert!(!NftToAsset::<Test>::contains_key((&nft_collection_id, &nft_id)));
+
+		assert!(events().contains(&Event::<Test>::NftUnified {
+			nft_collection: nft_collection_id,
+			nft: nft_id,
+			asset: asset_id,
+			beneficiary: account(1),
+		}));
+
+		// validate we need to hold the full balance to un-fractionalize the NFT
+		let asset_id = asset_id + 1;
+		assert_ok!(NftFractionalization::fractionalize(
+			RuntimeOrigin::signed(account(1)),
+			nft_collection_id,
+			nft_id,
+			asset_id,
+			account(1),
+			fractions,
+		));
+		assert_ok!(Assets::transfer(RuntimeOrigin::signed(account(1)), asset_id, account(2), 1));
+		assert_eq!(Assets::balance(asset_id, account(1)), fractions - 1);
+		assert_eq!(Assets::balance(asset_id, account(2)), 1);
+		assert_noop!(
+			NftFractionalization::unify(
+				RuntimeOrigin::signed(account(1)),
+				nft_collection_id,
+				nft_id,
+				asset_id,
+				account(1),
+			),
+			DispatchError::Token(FundsUnavailable)
+		);
+
+		assert_ok!(Assets::transfer(RuntimeOrigin::signed(account(2)), asset_id, account(1), 1));
+		assert_ok!(NftFractionalization::unify(
+			RuntimeOrigin::signed(account(1)),
+			nft_collection_id,
+			nft_id,
+			asset_id,
+			account(2),
+		));
+		assert_eq!(Nfts::owner(nft_collection_id, nft_id), Some(account(2)));
+	});
+}

bizinikiwi/pezframe/nft-fractionalization/src/types.rs

@@ -0,0 +1,76 @@
+// This file is part of Bizinikiwi.
+
+// Copyright (C) Parity Technologies (UK) Ltd.
+// SPDX-License-Identifier: Apache-2.0
+
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// 	http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+//! Various basic types for use in the Nft fractionalization pallet.
+
+use super::*;
+use codec::{Decode, Encode, MaxEncodedLen};
+use fungible::Inspect as FunInspect;
+use fungibles::Inspect;
+use scale_info::TypeInfo;
+
+pub type AssetIdOf<T> = <<T as Config>::Assets as Inspect<<T as SystemConfig>::AccountId>>::AssetId;
+pub type AssetBalanceOf<T> =
+	<<T as Config>::Assets as Inspect<<T as SystemConfig>::AccountId>>::Balance;
+pub type DepositOf<T> =
+	<<T as Config>::Currency as FunInspect<<T as SystemConfig>::AccountId>>::Balance;
+pub type AccountIdLookupOf<T> = <<T as SystemConfig>::Lookup as StaticLookup>::Source;
+
+/// Stores the details of a fractionalized item.
+#[derive(Decode, Encode, Default, PartialEq, Eq, MaxEncodedLen, TypeInfo)]
+pub struct Details<AssetId, Fractions, Deposit, AccountId> {
+	/// Minted asset.
+	pub asset: AssetId,
+
+	/// Number of fractions minted.
+	pub fractions: Fractions,
+
+	/// Reserved deposit for creating a new asset.
+	pub deposit: Deposit,
+
+	/// Account that fractionalized an item.
+	pub asset_creator: AccountId,
+}
+
+/// Benchmark Helper
+#[cfg(feature = "runtime-benchmarks")]
+pub trait BenchmarkHelper<AssetId, CollectionId, ItemId> {
+	/// Returns an asset id from a given integer.
+	fn asset(id: u32) -> AssetId;
+	/// Returns a collection id from a given integer.
+	fn collection(id: u32) -> CollectionId;
+	/// Returns an nft id from a given integer.
+	fn nft(id: u32) -> ItemId;
+}
+
+#[cfg(feature = "runtime-benchmarks")]
+impl<AssetId, CollectionId, ItemId> BenchmarkHelper<AssetId, CollectionId, ItemId> for ()
+where
+	AssetId: From<u32>,
+	CollectionId: From<u32>,
+	ItemId: From<u32>,
+{
+	fn asset(id: u32) -> AssetId {
+		id.into()
+	}
+	fn collection(id: u32) -> CollectionId {
+		id.into()
+	}
+	fn nft(id: u32) -> ItemId {
+		id.into()
+	}
+}

bizinikiwi/pezframe/nft-fractionalization/src/weights.rs

@@ -0,0 +1,210 @@
+// This file is part of Bizinikiwi.
+
+// Copyright (C) Parity Technologies (UK) Ltd.
+// SPDX-License-Identifier: Apache-2.0
+
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// 	http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// This file is part of Bizinikiwi.
+
+// Copyright (C) Parity Technologies (UK) Ltd.
+// SPDX-License-Identifier: Apache-2.0
+
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// 	http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+//! Autogenerated weights for `pezpallet_nft_fractionalization`
+//!
+//! THIS FILE WAS AUTO-GENERATED USING THE BIZINIKIWI BENCHMARK CLI VERSION 32.0.0
+//! DATE: 2025-02-21, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]`
+//! WORST CASE MAP SIZE: `1000000`
+//! HOSTNAME: `4563561839a5`, CPU: `Intel(R) Xeon(R) CPU @ 2.60GHz`
+//! WASM-EXECUTION: `Compiled`, CHAIN: `None`, DB CACHE: `1024`
+
+// Executed Command:
+// frame-omni-bencher
+// v1
+// benchmark
+// pallet
+// --extrinsic=*
+// --runtime=target/production/wbuild/kitchensink-runtime/kitchensink_runtime.wasm
+// --pallet=pezpallet_nft_fractionalization
+// --header=/__w/pezkuwi-sdk/pezkuwi-sdk/bizinikiwi/HEADER-APACHE2
+// --output=/__w/pezkuwi-sdk/pezkuwi-sdk/bizinikiwi/pezframe/nft-fractionalization/src/weights.rs
+// --wasm-execution=compiled
+// --steps=50
+// --repeat=20
+// --heap-pages=4096
+// --template=bizinikiwi/.maintain/frame-weight-template.hbs
+// --no-storage-info
+// --no-min-squares
+// --no-median-slopes
+// --genesis-builder-policy=none
+// --exclude-pallets=pezpallet_xcm,pezpallet_xcm_benchmarks::fungible,pezpallet_xcm_benchmarks::generic,pezpallet_nomination_pools,pezpallet_remark,pezpallet_transaction_storage,pezpallet_election_provider_multi_block,pezpallet_election_provider_multi_block::signed,pezpallet_election_provider_multi_block::unsigned,pezpallet_election_provider_multi_block::verifier
+
+#![cfg_attr(rustfmt, rustfmt_skip)]
+#![allow(unused_parens)]
+#![allow(unused_imports)]
+#![allow(missing_docs)]
+#![allow(dead_code)]
+
+use frame::weights_prelude::*;
+use core::marker::PhantomData;
+
+/// Weight functions needed for `pezpallet_nft_fractionalization`.
+pub trait WeightInfo {
+	fn fractionalize() -> Weight;
+	fn unify() -> Weight;
+}
+
+/// Weights for `pezpallet_nft_fractionalization` using the Bizinikiwi node and recommended hardware.
+pub struct BizinikiwiWeight<T>(PhantomData<T>);
+impl<T: pezframe_system::Config> WeightInfo for BizinikiwiWeight<T> {
+	/// Storage: `Nfts::Item` (r:1 w:0)
+	/// Proof: `Nfts::Item` (`max_values`: None, `max_size`: Some(861), added: 3336, mode: `MaxEncodedLen`)
+	/// Storage: `Balances::Holds` (r:1 w:1)
+	/// Proof: `Balances::Holds` (`max_values`: None, `max_size`: Some(427), added: 2902, mode: `MaxEncodedLen`)
+	/// Storage: `Nfts::Attribute` (r:1 w:1)
+	/// Proof: `Nfts::Attribute` (`max_values`: None, `max_size`: Some(479), added: 2954, mode: `MaxEncodedLen`)
+	/// Storage: `Nfts::Collection` (r:1 w:1)
+	/// Proof: `Nfts::Collection` (`max_values`: None, `max_size`: Some(84), added: 2559, mode: `MaxEncodedLen`)
+	/// 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: `Assets::Account` (r:1 w:1)
+	/// Proof: `Assets::Account` (`max_values`: None, `max_size`: Some(134), added: 2609, mode: `MaxEncodedLen`)
+	/// Storage: `System::Account` (r:1 w:1)
+	/// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `MaxEncodedLen`)
+	/// Storage: `Assets::Metadata` (r:1 w:1)
+	/// Proof: `Assets::Metadata` (`max_values`: None, `max_size`: Some(140), added: 2615, mode: `MaxEncodedLen`)
+	/// Storage: `NftFractionalization::NftToAsset` (r:0 w:1)
+	/// Proof: `NftFractionalization::NftToAsset` (`max_values`: None, `max_size`: Some(92), added: 2567, mode: `MaxEncodedLen`)
+	fn fractionalize() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `364`
+		//  Estimated: `4326`
+		// Minimum execution time: 173_042_000 picoseconds.
+		Weight::from_parts(176_398_000, 4326)
+			.saturating_add(T::DbWeight::get().reads(9_u64))
+			.saturating_add(T::DbWeight::get().writes(8_u64))
+	}
+	/// Storage: `NftFractionalization::NftToAsset` (r:1 w:1)
+	/// Proof: `NftFractionalization::NftToAsset` (`max_values`: None, `max_size`: Some(92), added: 2567, mode: `MaxEncodedLen`)
+	/// 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: `Nfts::Attribute` (r:1 w:1)
+	/// Proof: `Nfts::Attribute` (`max_values`: None, `max_size`: Some(479), added: 2954, mode: `MaxEncodedLen`)
+	/// Storage: `Nfts::Collection` (r:1 w:1)
+	/// Proof: `Nfts::Collection` (`max_values`: None, `max_size`: Some(84), added: 2559, mode: `MaxEncodedLen`)
+	/// Storage: `Nfts::CollectionConfigOf` (r:1 w:0)
+	/// Proof: `Nfts::CollectionConfigOf` (`max_values`: None, `max_size`: Some(73), added: 2548, mode: `MaxEncodedLen`)
+	/// Storage: `Nfts::ItemConfigOf` (r:1 w:0)
+	/// Proof: `Nfts::ItemConfigOf` (`max_values`: None, `max_size`: Some(48), added: 2523, mode: `MaxEncodedLen`)
+	/// Storage: `Nfts::Item` (r:1 w:1)
+	/// Proof: `Nfts::Item` (`max_values`: None, `max_size`: Some(861), added: 3336, mode: `MaxEncodedLen`)
+	/// Storage: `Balances::Holds` (r:1 w:1)
+	/// Proof: `Balances::Holds` (`max_values`: None, `max_size`: Some(427), added: 2902, mode: `MaxEncodedLen`)
+	/// Storage: `Nfts::Account` (r:0 w:1)
+	/// Proof: `Nfts::Account` (`max_values`: None, `max_size`: Some(88), added: 2563, mode: `MaxEncodedLen`)
+	/// Storage: `Nfts::ItemPriceOf` (r:0 w:1)
+	/// Proof: `Nfts::ItemPriceOf` (`max_values`: None, `max_size`: Some(89), added: 2564, mode: `MaxEncodedLen`)
+	/// Storage: `Nfts::PendingSwapOf` (r:0 w:1)
+	/// Proof: `Nfts::PendingSwapOf` (`max_values`: None, `max_size`: Some(71), added: 2546, mode: `MaxEncodedLen`)
+	fn unify() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `1174`
+		//  Estimated: `4326`
+		// Minimum execution time: 124_038_000 picoseconds.
+		Weight::from_parts(127_219_000, 4326)
+			.saturating_add(T::DbWeight::get().reads(9_u64))
+			.saturating_add(T::DbWeight::get().writes(10_u64))
+	}
+}
+
+// For backwards compatibility and tests.
+impl WeightInfo for () {
+	/// Storage: `Nfts::Item` (r:1 w:0)
+	/// Proof: `Nfts::Item` (`max_values`: None, `max_size`: Some(861), added: 3336, mode: `MaxEncodedLen`)
+	/// Storage: `Balances::Holds` (r:1 w:1)
+	/// Proof: `Balances::Holds` (`max_values`: None, `max_size`: Some(427), added: 2902, mode: `MaxEncodedLen`)
+	/// Storage: `Nfts::Attribute` (r:1 w:1)
+	/// Proof: `Nfts::Attribute` (`max_values`: None, `max_size`: Some(479), added: 2954, mode: `MaxEncodedLen`)
+	/// Storage: `Nfts::Collection` (r:1 w:1)
+	/// Proof: `Nfts::Collection` (`max_values`: None, `max_size`: Some(84), added: 2559, mode: `MaxEncodedLen`)
+	/// 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: `Assets::Account` (r:1 w:1)
+	/// Proof: `Assets::Account` (`max_values`: None, `max_size`: Some(134), added: 2609, mode: `MaxEncodedLen`)
+	/// Storage: `System::Account` (r:1 w:1)
+	/// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `MaxEncodedLen`)
+	/// Storage: `Assets::Metadata` (r:1 w:1)
+	/// Proof: `Assets::Metadata` (`max_values`: None, `max_size`: Some(140), added: 2615, mode: `MaxEncodedLen`)
+	/// Storage: `NftFractionalization::NftToAsset` (r:0 w:1)
+	/// Proof: `NftFractionalization::NftToAsset` (`max_values`: None, `max_size`: Some(92), added: 2567, mode: `MaxEncodedLen`)
+	fn fractionalize() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `364`
+		//  Estimated: `4326`
+		// Minimum execution time: 173_042_000 picoseconds.
+		Weight::from_parts(176_398_000, 4326)
+			.saturating_add(RocksDbWeight::get().reads(9_u64))
+			.saturating_add(RocksDbWeight::get().writes(8_u64))
+	}
+	/// Storage: `NftFractionalization::NftToAsset` (r:1 w:1)
+	/// Proof: `NftFractionalization::NftToAsset` (`max_values`: None, `max_size`: Some(92), added: 2567, mode: `MaxEncodedLen`)
+	/// 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: `Nfts::Attribute` (r:1 w:1)
+	/// Proof: `Nfts::Attribute` (`max_values`: None, `max_size`: Some(479), added: 2954, mode: `MaxEncodedLen`)
+	/// Storage: `Nfts::Collection` (r:1 w:1)
+	/// Proof: `Nfts::Collection` (`max_values`: None, `max_size`: Some(84), added: 2559, mode: `MaxEncodedLen`)
+	/// Storage: `Nfts::CollectionConfigOf` (r:1 w:0)
+	/// Proof: `Nfts::CollectionConfigOf` (`max_values`: None, `max_size`: Some(73), added: 2548, mode: `MaxEncodedLen`)
+	/// Storage: `Nfts::ItemConfigOf` (r:1 w:0)
+	/// Proof: `Nfts::ItemConfigOf` (`max_values`: None, `max_size`: Some(48), added: 2523, mode: `MaxEncodedLen`)
+	/// Storage: `Nfts::Item` (r:1 w:1)
+	/// Proof: `Nfts::Item` (`max_values`: None, `max_size`: Some(861), added: 3336, mode: `MaxEncodedLen`)
+	/// Storage: `Balances::Holds` (r:1 w:1)
+	/// Proof: `Balances::Holds` (`max_values`: None, `max_size`: Some(427), added: 2902, mode: `MaxEncodedLen`)
+	/// Storage: `Nfts::Account` (r:0 w:1)
+	/// Proof: `Nfts::Account` (`max_values`: None, `max_size`: Some(88), added: 2563, mode: `MaxEncodedLen`)
+	/// Storage: `Nfts::ItemPriceOf` (r:0 w:1)
+	/// Proof: `Nfts::ItemPriceOf` (`max_values`: None, `max_size`: Some(89), added: 2564, mode: `MaxEncodedLen`)
+	/// Storage: `Nfts::PendingSwapOf` (r:0 w:1)
+	/// Proof: `Nfts::PendingSwapOf` (`max_values`: None, `max_size`: Some(71), added: 2546, mode: `MaxEncodedLen`)
+	fn unify() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `1174`
+		//  Estimated: `4326`
+		// Minimum execution time: 124_038_000 picoseconds.
+		Weight::from_parts(127_219_000, 4326)
+			.saturating_add(RocksDbWeight::get().reads(9_u64))
+			.saturating_add(RocksDbWeight::get().writes(10_u64))
+	}
+}