NFTs fractionalization

Cargo.toml

@@ -129,6 +129,7 @@ members = [
 	"frame/message-queue",
 	"frame/nfts",
 	"frame/nfts/runtime-api",
+	"frame/nft-fractionalization",
 	"frame/nomination-pools",
 	"frame/nomination-pools/fuzzer",
 	"frame/nomination-pools/benchmarking",

bin/node/runtime/Cargo.toml

@@ -85,6 +85,7 @@ pallet-mmr = { version = "4.0.0-dev", default-features = false, path = "../../..
 pallet-multisig = { version = "4.0.0-dev", default-features = false, path = "../../../frame/multisig" }
 pallet-nfts = { version = "4.0.0-dev", default-features = false, path = "../../../frame/nfts" }
 pallet-nfts-runtime-api = { version = "4.0.0-dev", default-features = false, path = "../../../frame/nfts/runtime-api" }
+pallet-nft-fractionalization = { version = "4.0.0-dev", default-features = false, path = "../../../frame/nft-fractionalization" }
 pallet-nomination-pools = { version = "1.0.0", default-features = false, path = "../../../frame/nomination-pools"}
 pallet-nomination-pools-benchmarking = { version = "1.0.0", default-features = false, optional = true, path = "../../../frame/nomination-pools/benchmarking" }
 pallet-nomination-pools-runtime-api = { version = "1.0.0-dev", default-features = false, path = "../../../frame/nomination-pools/runtime-api" }
@@ -219,6 +220,7 @@ std = [
 	"pallet-uniques/std",
 	"pallet-nfts/std",
 	"pallet-nfts-runtime-api/std",
+	"pallet-nft-fractionalization/std",
 	"pallet-vesting/std",
 	"log/std",
 	"frame-try-runtime?/std",
@@ -283,6 +285,7 @@ runtime-benchmarks = [
 	"pallet-utility/runtime-benchmarks",
 	"pallet-uniques/runtime-benchmarks",
 	"pallet-nfts/runtime-benchmarks",
+	"pallet-nft-fractionalization/runtime-benchmarks",
 	"pallet-vesting/runtime-benchmarks",
 	"pallet-whitelist/runtime-benchmarks",
 	"frame-system-benchmarking/runtime-benchmarks",
@@ -349,6 +352,7 @@ try-runtime = [
 	"pallet-transaction-storage/try-runtime",
 	"pallet-uniques/try-runtime",
 	"pallet-nfts/try-runtime",
+	"pallet-nft-fractionalization/try-runtime",
 	"pallet-vesting/try-runtime",
 	"pallet-whitelist/try-runtime",
 ]

bin/node/runtime/src/lib.rs

@@ -44,7 +44,7 @@ use frame_support::{
 		},
 		ConstantMultiplier, IdentityFee, Weight,
 	},
-	PalletId, RuntimeDebug,
+	BoundedVec, PalletId, RuntimeDebug,
 };
 use frame_system::{
 	limits::{BlockLength, BlockWeights},
@@ -445,6 +445,8 @@ parameter_types! {
 pub enum HoldReason {
 	/// The NIS Pallet has reserved it for a non-fungible receipt.
 	Nis,
+	/// Used by the NFT Fractionalization Pallet.
+	NftFractionalization,
 }
 
 impl pallet_balances::Config for Runtime {
@@ -460,7 +462,7 @@ impl pallet_balances::Config for Runtime {
 	type FreezeIdentifier = ();
 	type MaxFreezes = ();
 	type HoldIdentifier = HoldReason;
-	type MaxHolds = ConstU32<1>;
+	type MaxHolds = ConstU32<2>;
 }
 
 parameter_types! {
@@ -1612,6 +1614,33 @@ impl pallet_core_fellowship::Config for Runtime {
 	type EvidenceSize = ConstU32<16_384>;
 }
 
+parameter_types! {
+	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();
+	pub const NftFractionalizationHoldReason: HoldReason = HoldReason::NftFractionalization;
+}
+
+impl pallet_nft_fractionalization::Config for Runtime {
+	type RuntimeEvent = RuntimeEvent;
+	type Deposit = AssetDeposit;
+	type Currency = Balances;
+	type NewAssetSymbol = NewAssetSymbol;
+	type NewAssetName = NewAssetName;
+	type StringLimit = StringLimit;
+	type NftCollectionId = <Self as pallet_nfts::Config>::CollectionId;
+	type NftId = <Self as pallet_nfts::Config>::ItemId;
+	type AssetBalance = <Self as pallet_balances::Config>::Balance;
+	type AssetId = <Self as pallet_assets::Config>::AssetId;
+	type Assets = Assets;
+	type Nfts = Nfts;
+	type PalletId = NftFractionalizationPalletId;
+	type WeightInfo = pallet_nft_fractionalization::weights::SubstrateWeight<Runtime>;
+	type HoldReason = NftFractionalizationHoldReason;
+	#[cfg(feature = "runtime-benchmarks")]
+	type BenchmarkHelper = ();
+}
+
 parameter_types! {
 	pub Features: PalletFeatures = PalletFeatures::all_enabled();
 	pub const MaxAttributesPerCall: u32 = 10;
@@ -1829,6 +1858,7 @@ construct_runtime!(
 		Nis: pallet_nis,
 		Uniques: pallet_uniques,
 		Nfts: pallet_nfts,
+		NftFractionalization: pallet_nft_fractionalization,
 		Salary: pallet_salary,
 		CoreFellowship: pallet_core_fellowship,
 		TransactionStorage: pallet_transaction_storage,
@@ -1972,6 +2002,7 @@ mod benches {
 		[pallet_asset_rate, AssetRate]
 		[pallet_uniques, Uniques]
 		[pallet_nfts, Nfts]
+		[pallet_nft_fractionalization, NftFractionalization]
 		[pallet_utility, Utility]
 		[pallet_vesting, Vesting]
 		[pallet_whitelist, Whitelist]

frame/assets/src/functions.rs

@@ -962,9 +962,7 @@ impl<T: Config<I>, I: 'static> Pallet<T, I> {
 			ensure!(metadata.as_ref().map_or(true, |m| !m.is_frozen), Error::<T, I>::NoPermission);
 
 			let old_deposit = metadata.take().map_or(Zero::zero(), |m| m.deposit);
-			let new_deposit = T::MetadataDepositPerByte::get()
-				.saturating_mul(((name.len() + symbol.len()) as u32).into())
-				.saturating_add(T::MetadataDepositBase::get());
+			let new_deposit = Self::calc_metadata_deposit(&name, &symbol);
 
 			if new_deposit > old_deposit {
 				T::Currency::reserve(from, new_deposit - old_deposit)?;
@@ -991,6 +989,13 @@ impl<T: Config<I>, I: 'static> Pallet<T, I> {
 		})
 	}
 
+	/// Calculate the metadata deposit for the provided data.
+	pub(super) fn calc_metadata_deposit(name: &[u8], symbol: &[u8]) -> DepositBalanceOf<T, I> {
+		T::MetadataDepositPerByte::get()
+			.saturating_mul(((name.len() + symbol.len()) as u32).into())
+			.saturating_add(T::MetadataDepositBase::get())
+	}
+
 	/// Returns all the non-zero balances for all assets of the given `account`.
 	pub fn account_balances(account: T::AccountId) -> Vec<(T::AssetId, T::Balance)> {
 		Asset::<T, I>::iter_keys()

frame/assets/src/impl_fungibles.rs

@@ -226,6 +226,19 @@ impl<T: Config<I>, I: 'static> fungibles::metadata::Mutate<<T as SystemConfig>::
 	}
 }
 
+impl<T: Config<I>, I: 'static>
+	fungibles::metadata::MetadataDeposit<
+		<T::Currency as Currency<<T as SystemConfig>::AccountId>>::Balance,
+	> for Pallet<T, I>
+{
+	fn calc_metadata_deposit(
+		name: &[u8],
+		symbol: &[u8],
+	) -> <T::Currency as Currency<<T as SystemConfig>::AccountId>>::Balance {
+		Self::calc_metadata_deposit(&name, &symbol)
+	}
+}
+
 impl<T: Config<I>, I: 'static> fungibles::approvals::Inspect<<T as SystemConfig>::AccountId>
 	for Pallet<T, I>
 {

frame/nft-fractionalization/Cargo.toml

@@ -0,0 +1,52 @@
+[package]
+name = "pallet-nft-fractionalization"
+version = "4.0.0-dev"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2021"
+license = "Apache-2.0"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+description = "FRAME pallet to convert non-fungible to fungible tokens."
+readme = "README.md"
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+codec = { package = "parity-scale-codec", version = "3.2.2", default-features = false }
+log = { version = "0.4.17", default-features = false }
+scale-info = { version = "2.5.0", default-features = false, features = ["derive"] }
+frame-benchmarking = { version = "4.0.0-dev", default-features = false, optional = true, path = "../benchmarking" }
+frame-support = { version = "4.0.0-dev", default-features = false, path = "../support" }
+frame-system = { version = "4.0.0-dev", default-features = false, path = "../system" }
+pallet-assets = { version = "4.0.0-dev", default-features = false, path = "../assets" }
+pallet-nfts = { version = "4.0.0-dev", default-features = false, path = "../nfts" }
+sp-runtime = { version = "7.0.0", default-features = false, path = "../../primitives/runtime" }
+sp-std = { version = "5.0.0", default-features = false, path = "../../primitives/std" }
+
+[dev-dependencies]
+pallet-balances = { version = "4.0.0-dev", path = "../balances" }
+sp-core = { version = "7.0.0", path = "../../primitives/core" }
+sp-io = { version = "7.0.0", path = "../../primitives/io" }
+sp-std = { version = "5.0.0", path = "../../primitives/std" }
+
+[features]
+default = ["std"]
+std = [
+	"codec/std",
+	"frame-benchmarking/std",
+	"frame-support/std",
+	"frame-system/std",
+	"log/std",
+	"pallet-assets/std",
+	"pallet-nfts/std",
+	"scale-info/std",
+	"sp-runtime/std",
+	"sp-std/std",
+]
+runtime-benchmarks = [
+	"frame-benchmarking/runtime-benchmarks",
+	"frame-system/runtime-benchmarks",
+	"sp-runtime/runtime-benchmarks",
+]
+try-runtime = ["frame-support/try-runtime"]

frame/nft-fractionalization/README.md

@@ -0,0 +1,6 @@
+### Lock NFT
+
+Lock an NFT from `pallet-nfts` and mint fungible assets from `pallet-assets`.
+
+The NFT gets locked by putting a system-level attribute named `Locked`. This prevents the NFT from being transferred further.
+The NFT becomes unlocked when the `Locked` attribute is removed. In order to unify the fungible asset and unlock the NFT, an account must hold the full issuance of the asset the NFT was fractionalised into. Holding less of the fungible asset will not allow the unlocking of the NFT. 

frame/nft-fractionalization/src/benchmarking.rs

@@ -0,0 +1,135 @@
+// This file is part of Substrate.
+
+// Copyright (C) 2020-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.
+
+//! Nft fractionalization pallet benchmarking.
+
+#![cfg(feature = "runtime-benchmarks")]
+
+use super::*;
+use frame_benchmarking::{benchmarks, whitelisted_caller};
+use frame_support::{
+	assert_ok,
+	traits::{
+		fungible::{Inspect as InspectFungible, Mutate as MutateFungible},
+		tokens::nonfungibles_v2::{Create, Mutate},
+		Get,
+	},
+};
+use frame_system::RawOrigin as SystemOrigin;
+use pallet_nfts::{CollectionConfig, CollectionSettings, ItemConfig, MintSettings};
+use sp_runtime::traits::StaticLookup;
+use sp_std::prelude::*;
+
+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>,
+	<T as SystemConfig>::BlockNumber,
+	<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>, T::BlockNumber, 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 = frame_system::Pallet::<T>::events();
+	let system_event: <T as frame_system::Config>::RuntimeEvent = generic_event.into();
+	// compare to the last event record
+	let frame_system::EventRecord { event, .. } = &events[events.len() - 1];
+	assert_eq!(event, &system_event);
+}
+
+benchmarks! {
+	where_clause {
+		where
+			T::Nfts: Create<T::AccountId, CollectionConfig<BalanceOf<T>, T::BlockNumber, T::NftCollectionId>>
+				+ Mutate<T::AccountId, ItemConfig>,
+	}
+
+	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);
+	}: _(SystemOrigin::Signed(caller.clone()), collection, nft, asset, caller_lookup, 1000u32.into())
+	verify {
+		assert_last_event::<T>(
+			Event::NftFractionalized {
+				nft_collection: collection,
+				nft,
+				fractions: 1000u32.into(),
+				asset,
+				beneficiary: caller,
+			}.into()
+		);
+	}
+
+	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);
+		NftFractionalization::<T>::fractionalize(
+			SystemOrigin::Signed(caller.clone()).into(),
+			collection,
+			nft,
+			asset,
+			caller_lookup.clone(),
+			1000u32.into(),
+		)?;
+	}: _(SystemOrigin::Signed(caller.clone()), collection, nft, asset, caller_lookup)
+	verify {
+		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);
+}