NFTs fractionalization

Cargo.toml

@@ -124,6 +124,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

@@ -81,6 +81,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" }
@@ -207,6 +208,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",
@@ -267,6 +269,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",
@@ -329,6 +332,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

@@ -34,8 +34,8 @@ use frame_support::{
 	traits::{
 		fungible::ItemOf, tokens::nonfungibles_v2::Inspect, AsEnsureOriginWithArg, ConstBool,
 		ConstU128, ConstU16, ConstU32, Currency, EitherOfDiverse, EqualPrivilegeOnly, Everything,
-		Imbalance, InstanceFilter, KeyOwnerProofSystem, LockIdentifier, Nothing, OnUnbalanced,
-		U128CurrencyToVote, WithdrawReasons,
+		Imbalance, InstanceFilter, KeyOwnerProofSystem, LockIdentifier, Locker, Nothing,
+		OnUnbalanced, U128CurrencyToVote, WithdrawReasons,
 	},
 	weights::{
 		constants::{
@@ -56,7 +56,7 @@ use pallet_grandpa::{
 	fg_primitives, AuthorityId as GrandpaId, AuthorityList as GrandpaAuthorityList,
 };
 use pallet_im_online::sr25519::AuthorityId as ImOnlineId;
-use pallet_nfts::PalletFeatures;
+use pallet_nfts::{PalletFeatures, LOCKED_NFT_KEY};
 use pallet_nis::WithMaximumOf;
 use pallet_session::historical::{self as pallet_session_historical};
 pub use pallet_transaction_payment::{CurrencyAdapter, Multiplier, TargetedFeeAdjustment};
@@ -1575,6 +1575,16 @@ parameter_types! {
 	pub const MaxAttributesPerCall: u32 = 10;
 }
 
+type ItemId = <Runtime as pallet_nfts::Config>::ItemId;
+type CollectionId = <Runtime as pallet_nfts::Config>::CollectionId;
+
+pub struct NftLocker;
+impl Locker<CollectionId, ItemId> for NftLocker {
+	fn is_locked(collection: CollectionId, item: ItemId) -> bool {
+		<Nfts as Inspect<AccountId>>::system_attribute(&collection, &item, LOCKED_NFT_KEY).is_some()
+	}
+}
+
 impl pallet_nfts::Config for Runtime {
 	type RuntimeEvent = RuntimeEvent;
 	type CollectionId = u32;
@@ -1601,7 +1611,29 @@ impl pallet_nfts::Config for Runtime {
 	#[cfg(feature = "runtime-benchmarks")]
 	type Helper = ();
 	type CreateOrigin = AsEnsureOriginWithArg<EnsureSigned<AccountId>>;
-	type Locker = ();
+	type Locker = NftLocker;
+}
+
+parameter_types! {
+	pub const NftFractionalizationPalletId: PalletId = PalletId(*b"fraction");
+	pub NewAssetSymbol: Vec<u8> = (*b"FRAC").into();
+	pub NewAssetName: Vec<u8> = (*b"Frac").into();
+}
+
+impl pallet_nft_fractionalization::Config for Runtime {
+	type RuntimeEvent = RuntimeEvent;
+	type Deposit = AssetDeposit;
+	type Currency = Balances;
+	type NewAssetSymbol = NewAssetSymbol;
+	type NewAssetName = NewAssetName;
+	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>;
 }
 
 impl pallet_transaction_storage::Config for Runtime {
@@ -1765,6 +1797,7 @@ construct_runtime!(
 		Nis: pallet_nis,
 		Uniques: pallet_uniques,
 		Nfts: pallet_nfts,
+		NftFractionalization: pallet_nft_fractionalization,
 		TransactionStorage: pallet_transaction_storage,
 		VoterList: pallet_bags_list::<Instance1>,
 		StateTrieMigration: pallet_state_trie_migration,
@@ -1896,6 +1929,7 @@ mod benches {
 		[pallet_treasury, Treasury]
 		[pallet_uniques, Uniques]
 		[pallet_nfts, Nfts]
+		[pallet_nft_fractionalization, NftFractionalization]
 		[pallet_utility, Utility]
 		[pallet_vesting, Vesting]
 		[pallet_whitelist, Whitelist]

frame/assets/src/functions.rs

@@ -896,9 +896,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)?;
@@ -924,4 +922,14 @@ impl<T: Config<I>, I: 'static> Pallet<T, I> {
 			Ok(())
 		})
 	}
+
+	/// Calculate the metadata deposit for the provided data.
+	pub(super) fn calc_metadata_deposit(
+		name: &Vec<u8>,
+		symbol: &Vec<u8>,
+	) -> DepositBalanceOf<T, I> {
+		T::MetadataDepositPerByte::get()
+			.saturating_mul(((name.len() + symbol.len()) as u32).into())
+			.saturating_add(T::MetadataDepositBase::get())
+	}
 }

frame/assets/src/impl_fungibles.rs

@@ -231,6 +231,19 @@ impl<T: Config<I>, I: 'static> fungibles::metadata::Mutate<<T as SystemConfig>::
 	}
 }
 
+impl<T: Config<I>, I: 'static>
+	fungibles::metadata::CalcMetadataDeposit<
+		<T::Currency as Currency<<T as SystemConfig>::AccountId>>::Balance,
+	> for Pallet<T, I>
+{
+	fn calc(
+		name: &Vec<u8>,
+		symbol: &Vec<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,46 @@
+[package]
+name = "pallet-nft-fractionalization"
+version = "4.0.0-dev"
+description = "FRAME pallet for semi-fungible tokens."
+authors = ["Parity Technologies <[email protected]>"]
+homepage = "https://substrate.io"
+edition = "2021"
+repository = "https://github.com/paritytech/substrate/"
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+codec = { package = "parity-scale-codec", version = "3.0.0", default-features = false }
+log = { version = "0.4.17", default-features = false }
+scale-info = { version = "2.1.1", 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"]
+try-runtime = ["frame-support/try-runtime"]

frame/nft-fractionalization/README.md

@@ -0,0 +1,3 @@
+### Lock NFT
+
+Lock an NFT from `pallet-nfts` and mint fungible assets from `pallet-assets`.

frame/nft-fractionalization/src/benchmarking.rs

@@ -0,0 +1,131 @@
+// 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, Unbalanced},
+		tokens::nonfungibles_v2::{Create, Mutate},
+	},
+};
+use frame_system::RawOrigin as SystemOrigin;
+use pallet_nfts::{CollectionConfig, CollectionSettings, ItemConfig, MintSettings};
+use sp_runtime::traits::{Bounded, 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::NftCollectionId: From<u32>,
+	T::Currency: Unbalanced<T::AccountId>,
+	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());
+	assert_ok!(T::Currency::set_balance(&caller, BalanceOf::<T>::max_value()));
+	assert_ok!(T::Nfts::create_collection(&caller, &caller, &default_collection_config::<T>()));
+	assert_ok!(T::Nfts::mint_into(&0.into(), &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::AssetBalance: From<u64>,
+			T::AssetId: From<u32>,
+			T::NftCollectionId: From<u32>,
+			T::NftId: From<u32>,
+			T::Currency: Unbalanced<T::AccountId>,
+			T::Nfts: Create<T::AccountId, CollectionConfig<BalanceOf<T>, T::BlockNumber, T::NftCollectionId>>
+				+ Mutate<T::AccountId, ItemConfig>,
+	}
+
+	fractionalize {
+		let (caller, caller_lookup) = mint_nft::<T>(0.into());
+	}: _(SystemOrigin::Signed(caller.clone()), 0.into(), 0.into(), 0.into(), caller_lookup, 1000u32.into())
+	verify {
+		assert_last_event::<T>(
+			Event::NftFractionalized {
+				nft_collection: 0.into(),
+				nft: 0.into(),
+				fractions: 1000u32.into(),
+				asset: 0.into(),
+				beneficiary: caller,
+			}.into()
+		);
+	}
+
+	unify {
+		let (caller, caller_lookup) = mint_nft::<T>(0.into());
+		NftFractionalization::<T>::fractionalize(
+			SystemOrigin::Signed(caller.clone()).into(),
+			0.into(),
+			0.into(),
+			0.into(),
+			caller_lookup.clone(),
+			1000u32.into(),
+		)?;
+	}: _(SystemOrigin::Signed(caller.clone()), 0.into(), 0.into(), 0.into(), caller_lookup)
+	verify {
+		assert_last_event::<T>(
+			Event::NftUnified {
+				nft_collection: 0.into(),
+				nft: 0.into(),
+				asset: 0.into(),
+				beneficiary: caller,
+			}.into()
+		);
+	}
+
+	impl_benchmark_test_suite!(NftFractionalization, crate::mock::new_test_ext(), crate::mock::Test);
+}