feat: nonfungibles testnet (#588)

* feat(testnet): nonfungibles

* fmt

* fmt

* revert: remove dao contract

Author: Daanvdplas

Cargo.lock

@@ -18,9 +18,8 @@ use utils::*;
 
 mod fungibles;
 #[cfg(feature = "testnet")]
-mod messaging;
-#[cfg(feature = "devnet")]
-mod nonfungibles;
+pub mod messaging;
+pub mod nonfungibles;
 mod utils;
 
 type Balance = u128;

pop-api/integration-tests/src/lib.rs

@@ -49,8 +49,8 @@ pallet-message-queue.workspace = true
 pallet-migrations.workspace = true
 pallet-multisig.workspace = true
 pallet-nft-fractionalization.workspace = true
+pallet-nfts.workspace = true
 pallet-nfts-runtime-api.workspace = true
-pallet-nfts-sdk.workspace = true
 pallet-preimage.workspace = true
 pallet-proxy.workspace = true
 pallet-revive.workspace = true
@@ -154,7 +154,7 @@ std = [
 	"pallet-multisig/std",
 	"pallet-nft-fractionalization/std",
 	"pallet-nfts-runtime-api/std",
-	"pallet-nfts-sdk/std",
+	"pallet-nfts/std",
 	"pallet-preimage/std",
 	"pallet-proxy/std",
 	"pallet-revive/std",
@@ -217,7 +217,7 @@ runtime-benchmarks = [
 	"pallet-motion/runtime-benchmarks",
 	"pallet-multisig/runtime-benchmarks",
 	"pallet-nft-fractionalization/runtime-benchmarks",
-	"pallet-nfts-sdk/runtime-benchmarks",
+	"pallet-nfts/runtime-benchmarks",
 	"pallet-preimage/runtime-benchmarks",
 	"pallet-proxy/runtime-benchmarks",
 	"pallet-revive/runtime-benchmarks",
@@ -263,7 +263,7 @@ try-runtime = [
 	"pallet-motion/try-runtime",
 	"pallet-multisig/try-runtime",
 	"pallet-nft-fractionalization/try-runtime",
-	"pallet-nfts-sdk/try-runtime",
+	"pallet-nfts/try-runtime",
 	"pallet-preimage/try-runtime",
 	"pallet-proxy/try-runtime",
 	"pallet-revive/try-runtime",

runtime/testnet/Cargo.toml

@@ -18,10 +18,12 @@ use xcm::prelude::Location;
 
 use crate::{
 	config::{
-		assets::TrustBackedAssetsInstance, monetary::TransactionByteFee, xcm::LocalOriginToLocation,
+		assets::{TrustBackedAssetsInstance, TrustBackedNftsInstance},
+		monetary::TransactionByteFee,
+		xcm::LocalOriginToLocation,
 	},
-	fungibles, AccountId, Balances, BlockNumber, Contracts, Ismp, PolkadotXcm, Runtime,
-	RuntimeCall, RuntimeHoldReason,
+	fungibles, nonfungibles, AccountId, Balances, BlockNumber, Contracts, Ismp, PolkadotXcm,
+	Runtime, RuntimeCall, RuntimeHoldReason,
 };
 
 mod versioning;
@@ -42,6 +44,9 @@ pub enum RuntimeRead {
 	/// Fungible token queries.
 	#[codec(index = 150)]
 	Fungibles(fungibles::Read<Runtime>),
+	/// Non-fungible token queries.
+	#[codec(index = 151)]
+	NonFungibles(nonfungibles::Read<Runtime>),
 	/// Messaging state queries.
 	#[codec(index = 152)]
 	Messaging(messaging::Read<Runtime>),
@@ -57,6 +62,7 @@ impl Readable for RuntimeRead {
 		match self {
 			RuntimeRead::Fungibles(key) => fungibles::Pallet::weight(key),
 			RuntimeRead::Messaging(key) => messaging::Pallet::weight(key),
+			RuntimeRead::NonFungibles(key) => nonfungibles::Pallet::weight(key),
 		}
 	}
 
@@ -65,6 +71,8 @@ impl Readable for RuntimeRead {
 		match self {
 			RuntimeRead::Fungibles(key) => RuntimeResult::Fungibles(fungibles::Pallet::read(key)),
 			RuntimeRead::Messaging(key) => RuntimeResult::Messaging(messaging::Pallet::read(key)),
+			RuntimeRead::NonFungibles(key) =>
+				RuntimeResult::NonFungibles(nonfungibles::Pallet::read(key)),
 		}
 	}
 }
@@ -77,6 +85,8 @@ pub enum RuntimeResult {
 	Fungibles(fungibles::ReadResult<Runtime>),
 	/// Messaging state read results.
 	Messaging(messaging::ReadResult),
+	/// Non-fungible token read results.
+	NonFungibles(nonfungibles::ReadResult<Runtime>),
 }
 
 impl RuntimeResult {
@@ -85,6 +95,7 @@ impl RuntimeResult {
 		match self {
 			RuntimeResult::Fungibles(result) => result.encode(),
 			RuntimeResult::Messaging(result) => result.encode(),
+			RuntimeResult::NonFungibles(result) => result.encode(),
 		}
 	}
 }
@@ -99,7 +110,7 @@ impl messaging::Config for Runtime {
 	type IsmpDispatcher = Ismp;
 	type MaxContextLen = ConstU32<64>;
 	type MaxDataLen = ConstU32<1024>;
-	type MaxKeyLen = ConstU32<32>;
+	type MaxKeyLen = ConstU32<1000>;
 	type MaxKeys = ConstU32<10>;
 	// TODO: size appropriately
 	type MaxRemovals = ConstU32<1024>;
@@ -193,6 +204,11 @@ impl fungibles::Config for Runtime {
 	type WeightInfo = fungibles::weights::SubstrateWeight<Runtime>;
 }
 
+impl nonfungibles::Config for Runtime {
+	type NftsInstance = TrustBackedNftsInstance;
+	type WeightInfo = ();
+}
+
 #[derive(Default)]
 pub struct Config;
 impl pallet_api::extension::Config for Config {
@@ -276,7 +292,28 @@ impl<T: frame_system::Config<RuntimeCall = RuntimeCall>> Contains<RuntimeCall> f
 			)
 		};
 
-		T::BaseCallFilter::contains(c) && contain_fungibles | contain_messaging
+		let contain_nonfungibles: bool =
+			{
+				use nonfungibles::Call::*;
+				matches!(
+					c,
+					RuntimeCall::NonFungibles(
+						approve { .. } |
+							transfer { .. } | create { .. } |
+							destroy { .. } | set_metadata { .. } |
+							clear_metadata { .. } | set_attribute { .. } |
+							clear_attribute { .. } |
+							set_max_supply { .. } | approve_item_attributes { .. } |
+							cancel_item_attributes_approval { .. } |
+							clear_all_transfer_approvals { .. } |
+							clear_collection_approvals { .. } |
+							mint { .. } | burn { .. },
+					)
+				)
+			};
+
+		T::BaseCallFilter::contains(c) &&
+			(contain_fungibles | contain_messaging | contain_nonfungibles)
 	}
 }
 
@@ -300,16 +337,30 @@ impl<T: frame_system::Config> Contains<RuntimeRead> for Filter<T> {
 			matches!(r, RuntimeRead::Messaging(Poll(..) | Get(..) | QueryId(..)))
 		};
 
-		contain_fungibles | contain_messaging
+		let contain_nonfungibles: bool = {
+			use nonfungibles::Read::*;
+			matches!(
+				r,
+				RuntimeRead::NonFungibles(
+					BalanceOf { .. } |
+						OwnerOf { .. } | Allowance { .. } |
+						TotalSupply(..) | GetAttribute { .. } |
+						ItemMetadata { .. } |
+						NextCollectionId,
+				)
+			)
+		};
+
+		contain_fungibles | contain_messaging | contain_nonfungibles
 	}
 }
 
 #[cfg(test)]
 mod tests {
 	use codec::Encode;
 	use pallet_api::fungibles::Call::*;
-	use sp_core::crypto::AccountId32;
-	use RuntimeCall::{Balances, Fungibles};
+	use sp_core::{bounded_vec, crypto::AccountId32};
+	use RuntimeCall::{Balances, Fungibles, NonFungibles};
 
 	use super::*;
 
@@ -384,4 +435,94 @@ mod tests {
 			assert!(Filter::<Runtime>::contains(&read))
 		}
 	}
+	#[test]
+	fn filter_allows_nonfungibles_calls() {
+		use pallet_api::nonfungibles::{
+			Call::*, CancelAttributesApprovalWitness, CollectionConfig, CollectionSettings,
+			DestroyWitness, MintSettings,
+		};
+
+		for call in vec![
+			NonFungibles(approve {
+				collection: 0,
+				item: Some(0),
+				operator: ACCOUNT,
+				approved: false,
+				deadline: None,
+			}),
+			NonFungibles(transfer { collection: 0, item: 0, to: ACCOUNT }),
+			NonFungibles(create {
+				admin: ACCOUNT,
+				config: CollectionConfig {
+					max_supply: Some(0),
+					mint_settings: MintSettings::default(),
+					settings: CollectionSettings::all_enabled(),
+				},
+			}),
+			NonFungibles(destroy {
+				collection: 0,
+				witness: DestroyWitness { attributes: 0, item_configs: 0, item_metadatas: 0 },
+			}),
+			NonFungibles(set_attribute {
+				collection: 0,
+				item: Some(0),
+				namespace: pallet_nfts::AttributeNamespace::Pallet,
+				key: bounded_vec![],
+				value: bounded_vec![],
+			}),
+			NonFungibles(clear_attribute {
+				collection: 0,
+				item: Some(0),
+				namespace: pallet_nfts::AttributeNamespace::Pallet,
+				key: bounded_vec![],
+			}),
+			NonFungibles(set_metadata { collection: 0, item: 0, data: bounded_vec![] }),
+			NonFungibles(clear_metadata { collection: 0, item: 0 }),
+			NonFungibles(set_max_supply { collection: 0, max_supply: 0 }),
+			NonFungibles(approve_item_attributes { collection: 0, item: 0, delegate: ACCOUNT }),
+			NonFungibles(cancel_item_attributes_approval {
+				collection: 0,
+				item: 0,
+				delegate: ACCOUNT,
+				witness: CancelAttributesApprovalWitness { account_attributes: 0 },
+			}),
+			NonFungibles(clear_all_transfer_approvals { collection: 0, item: 0 }),
+			NonFungibles(clear_collection_approvals { collection: 0, limit: 0 }),
+			NonFungibles(mint { to: ACCOUNT, collection: 0, item: 0, witness: None }),
+			NonFungibles(burn { collection: 0, item: 0 }),
+		]
+		.iter()
+		{
+			assert!(Filter::<Runtime>::contains(call))
+		}
+	}
+
+	#[test]
+	fn filter_allows_nonfungibles_reads() {
+		use super::{nonfungibles::Read::*, RuntimeRead::*};
+
+		for read in vec![
+			NonFungibles(BalanceOf { collection: 1, owner: ACCOUNT }),
+			NonFungibles(OwnerOf { collection: 1, item: 1 }),
+			NonFungibles(Allowance {
+				collection: 1,
+				owner: ACCOUNT,
+				operator: ACCOUNT,
+				item: None,
+			}),
+			NonFungibles(TotalSupply(1)),
+			NonFungibles(GetAttribute {
+				collection: 1,
+				item: Some(1),
+				namespace: pallet_nfts::AttributeNamespace::CollectionOwner,
+				key: bounded_vec![],
+			}),
+			NonFungibles(NextCollectionId),
+			NonFungibles(ItemMetadata { collection: 1, item: 1 }),
+		]
+		.iter()
+		{
+			assert!(Filter::<Runtime>::contains(read))
+		}
+	}
 }