stash

Author: tlacloc

.vscode/settings.json

@@ -0,0 +1,6 @@
+{
+  "cSpell.words": [
+    "Frunique"
+    , "fruniques"
+  ]
+}

Cargo.lock

@@ -26,6 +26,8 @@ sp-runtime ={ default-features = false, version = "6.0.0", git = "https://github
 pallet-uniques = { default-features = false, git = "https://github.com/paritytech/substrate.git", branch = "polkadot-v0.9.27" }
 pallet-balances = { default-features = false, git = "https://github.com/paritytech/substrate.git", branch = "polkadot-v0.9.27" }
 
+pallet-rbac = { path="../rbac/", default-features = false, version = "4.0.0-dev"}
+
 [dev-dependencies]
 sp-core = { default-features = false, version = "6.0.0", git = "https://github.com/paritytech/substrate.git", branch = "polkadot-v0.9.27" }
 sp-io = { default-features = false, git = "https://github.com/paritytech/substrate.git", branch = "polkadot-v0.9.27" }

pallets/fruniques/Cargo.toml

@@ -6,6 +6,8 @@ use crate::types::*;
 use frame_support::traits::tokens::nonfungibles::Inspect;
 use scale_info::prelude::string::String;
 
+use pallet_rbac::types::*;
+
 use frame_support::pallet_prelude::*;
 use sp_runtime::{sp_std::vec::Vec, Permill};
 
@@ -74,6 +76,12 @@ impl<T: Config> Pallet<T> {
 		false
 	}
 
+	pub fn do_initial_setup() -> DispatchResult {
+		let pallet_id = Self::pallet_id();
+
+		Ok(())
+	}
+
 	pub fn set_attribute(
 		origin: OriginFor<T>,
 		class_id: &T::CollectionId,
@@ -214,4 +222,11 @@ impl<T: Config> Pallet<T> {
 
 		Ok(())
 	}
+
+	pub fn pallet_id()->IdOrVec{
+        IdOrVec::Vec(
+            Self::module_name().as_bytes().to_vec()
+        )
+    }
+
 }

pallets/fruniques/src/functions.rs

@@ -8,28 +8,30 @@ mod mock;
 #[cfg(test)]
 mod tests;
 
-#[cfg(feature = "runtime-benchmarks")]
-mod benchmarking;
+// #[cfg(feature = "runtime-benchmarks")]
+// mod benchmarking;
 
-pub mod types;
 mod functions;
+pub mod types;
 
 #[frame_support::pallet]
 pub mod pallet {
 	use super::*;
-	use frame_support::{pallet_prelude::*, BoundedVec, transactional};
+	use crate::types::*;
+	use frame_support::{pallet_prelude::*, transactional, BoundedVec};
 	use frame_system::pallet_prelude::*;
 	use scale_info::prelude::vec::Vec;
-	use sp_runtime::{Permill};
-	use crate::types::*;
+	use sp_runtime::Permill;
 	/// Configure the pallet by specifying the parameters and types on which it depends.
 	#[pallet::config]
 	pub trait Config: frame_system::Config + pallet_uniques::Config {
-
 		type Event: From<Event<Self>> + IsType<<Self as frame_system::Config>::Event>;
 
 		type RemoveOrigin: EnsureOrigin<Self::Origin>;
 
+		/// Maximum number of children a Frunique can have
+		#[pallet::constant]
+		type ChildMaxLen: Get<u32>;
 	}
 
 	#[pallet::pallet]
@@ -66,26 +68,22 @@ pub mod pallet {
 		ValueTooLong,
 		// Calling set on a non-existing attributes
 		AttributesEmpty,
-		// The collection doenst exist
+		// The collection doesn't exist
 		CollectionNotFound,
 	}
 
 	#[pallet::storage]
 	#[pallet::getter(fn frunique_cnt)]
 	/// Keeps track of the number of Kitties in existence.
-	pub(super) type FruniqueCnt<T: Config> = StorageValue<
-		_,
-		ItemId,
-		ValueQuery
-	>;
+	pub(super) type FruniqueCnt<T: Config> = StorageValue<_, ItemId, ValueQuery>;
 
 	#[pallet::storage]
 	#[pallet::getter(fn next_collection)]
 	/// Keeps track of the number of collections in existence.
 	pub(super) type NextCollection<T: Config> = StorageValue<
 		_,
 		CollectionId, // Next collection id.
-		ValueQuery
+		ValueQuery,
 	>;
 
 	#[pallet::storage]
@@ -95,8 +93,8 @@ pub mod pallet {
 		_,
 		Blake2_128Concat,
 		CollectionId,
-		ItemId,  // The next frunique id for a collection.
-		ValueQuery
+		ItemId, // The next frunique id for a collection.
+		ValueQuery,
 	>;
 
 	#[pallet::storage]
@@ -107,9 +105,9 @@ pub mod pallet {
 		Blake2_128Concat,
 		CollectionId,
 		Blake2_128Concat,
-		ItemId, // FruniqueId
+		ItemId,                   // FruniqueId
 		Option<HierarchicalInfo>, // ParentId and flag if it inherit attributes
-		ValueQuery
+		ValueQuery,
 	>;
 
 	#[pallet::storage]
@@ -120,22 +118,19 @@ pub mod pallet {
 		Blake2_128Concat,
 		CollectionId,
 		Blake2_128Concat,
-		ItemId, // FruniqueId
+		ItemId,                   // FruniqueId
 		Option<HierarchicalInfo>, // ParentId and flag if it inherit attributes
-		ValueQuery
+		ValueQuery,
 	>;
 
-
 	#[pallet::call]
 	impl<T: Config> Pallet<T>
 	where
 		T: pallet_uniques::Config<CollectionId = CollectionId, ItemId = ItemId>,
 	{
 		#[transactional]
 		#[pallet::weight(10_000 + T::DbWeight::get().writes(10))]
-		pub fn initial_setup(
-			origin: OriginFor<T>,
-		) -> DispatchResult {
+		pub fn initial_setup(origin: OriginFor<T>) -> DispatchResult {
 			T::RemoveOrigin::ensure_origin(origin.clone())?;
 			// Self::do_initial_setup()?;
 			Ok(())
@@ -146,7 +141,6 @@ pub mod pallet {
 			origin: OriginFor<T>,
 			metadata: Option<StringLimit<T>>,
 		) -> DispatchResult {
-
 			let admin: T::AccountId = ensure_signed(origin.clone())?;
 
 			let new_collection_id: u32 = Self::next_collection().try_into().unwrap();
@@ -158,12 +152,9 @@ pub mod pallet {
 				Self::account_id_to_lookup_source(&admin),
 			)?;
 
-			Self::deposit_event(Event::FruniqueCollectionCreated(
-				admin,
-				new_collection_id,
-			));
+			Self::deposit_event(Event::FruniqueCollectionCreated(admin, new_collection_id));
 
-			<NextCollection<T>>::put(Self::next_collection() + 1 );
+			<NextCollection<T>>::put(Self::next_collection() + 1);
 
 			Ok(())
 		}
@@ -244,7 +235,6 @@ pub mod pallet {
 			parent_info: Option<HierarchicalInfo>,
 			attributes: Option<Vec<(BoundedVec<u8, T::KeyLimit>, BoundedVec<u8, T::ValueLimit>)>>,
 		) -> DispatchResult {
-
 			let owner: T::AccountId = ensure_signed(origin.clone())?;
 			let account_id = Self::account_id_to_lookup_source(&owner);
 
@@ -257,14 +247,22 @@ pub mod pallet {
 				instance_id,
 				account_id,
 				numeric_value,
-				attributes
+				attributes,
 			)?;
 
-			Self::deposit_event(Event::FruniqueCreated(owner.clone(), owner, class_id, instance_id));
+			Self::deposit_event(Event::FruniqueCreated(
+				owner.clone(),
+				owner,
+				class_id,
+				instance_id,
+			));
 
 			if let Some(parent_info) = parent_info {
 				// ! check if parent exists
-				ensure!(Self::item_exists(&class_id, &parent_info.0),  <Error<T>>::CollectionNotFound);
+				ensure!(
+					Self::item_exists(&class_id, &parent_info.0),
+					<Error<T>>::CollectionNotFound
+				);
 				<FruniqueParent<T>>::insert(class_id, instance_id, Some(parent_info));
 				// Self::do_hierarchical_division(origin.clone(), class_id, instance_id, parent_info)?;
 			}
@@ -284,15 +282,12 @@ pub mod pallet {
 		/// - This function is only available to the `admin` with sudo access.
 		#[transactional]
 		#[pallet::weight(10_000 + T::DbWeight::get().writes(1))]
-		pub fn kill_storage(
-			origin: OriginFor<T>,
-		) -> DispatchResult{
+		pub fn kill_storage(origin: OriginFor<T>) -> DispatchResult {
 			T::RemoveOrigin::ensure_origin(origin.clone())?;
 			let _ = <FruniqueCnt<T>>::put(0);
 			let _ = <NextCollection<T>>::put(0);
 			let _ = <NextFrunique<T>>::clear(1000, None);
 			Ok(())
 		}
-
 	}
 }

pallets/fruniques/src/lib.rs

@@ -26,6 +26,7 @@ construct_runtime!(
 );
 parameter_types! {
 	pub const BlockHashCount: u64 = 250;
+	pub const ChildMaxLen: u32 = 10;
 }
 impl frame_system::Config for Test {
 	type BaseCallFilter = frame_support::traits::Everything;
@@ -57,6 +58,7 @@ impl frame_system::Config for Test {
 impl pallet_fruniques::Config for Test {
 	type Event = Event;
 	type RemoveOrigin = EnsureRoot<Self::AccountId>;
+	type ChildMaxLen = ChildMaxLen;
 }
 
 parameter_types! {

pallets/fruniques/src/mock.rs

@@ -1,11 +1,15 @@
 //! Defines the types required by the fruniques pallet
-use sp_runtime::{sp_std::vec::Vec};
+use super::*;
 use frame_support::pallet_prelude::*;
 
+use frame_support::sp_io::hashing::blake2_256;
+use sp_runtime::sp_std::vec::Vec;
+
 pub type AttributeKey<T> = BoundedVec<u8, <T as pallet_uniques::Config>::KeyLimit>;
 pub type AttributeValue<T> = BoundedVec<u8, <T as pallet_uniques::Config>::ValueLimit>;
 pub type Attributes<T> = Vec<(AttributeKey<T>, AttributeValue<T>)>;
 
+pub type CollectionDescription = [u8;32];
 pub type StringLimit<T> = BoundedVec<u8, <T as pallet_uniques::Config>::StringLimit>;
 
 pub type CollectionId = u32;
@@ -21,10 +25,101 @@ pub struct FruniqueChild {
 	pub weight: u32,
 }
 
-#[derive(CloneNoBound, Encode, Decode, RuntimeDebugNoBound, TypeInfo, MaxEncodedLen,)]
+pub type ChildrenInfo =  BoundedVec<FruniqueChild, T::ChildMaxLen>;
+
+#[derive(CloneNoBound, Encode, Decode, RuntimeDebugNoBound, TypeInfo, MaxEncodedLen)]
 #[scale_info(skip_type_params(T))]
 #[codec(mel_bound())]
-pub struct FruniqueInheritance<T: pallet_uniques::Config> {
-	pub parent: Option<(CollectionId, ItemId)>,
-	pub children: Vec<(CollectionId, ItemId)>,
+pub struct FruniqueInheritance {
+	pub parent: (CollectionId, ItemId),
+	pub children: ChildrenInfo,
+}
+
+#[derive(
+	Encode, Decode, Clone, Eq, PartialEq, RuntimeDebugNoBound, MaxEncodedLen, TypeInfo, Copy,
+)]
+pub enum FruniqueRole {
+	Owner,
+	Admin,
+	Collaborator,
+	Collector,
+}
+
+impl Default for FruniqueRole {
+	fn default() -> Self {
+		FruniqueRole::Collector
+	}
+}
+
+impl FruniqueRole {
+	pub fn to_vec(self) -> Vec<u8> {
+		match self {
+			Self::Owner => "Owner".as_bytes().to_vec(),
+			Self::Admin => "Admin".as_bytes().to_vec(),
+			Self::Collaborator => "Collaborator".as_bytes().to_vec(),
+			Self::Collector => "Collector".as_bytes().to_vec(),
+		}
+	}
+
+	pub fn id(&self) -> [u8; 32] {
+		self.to_vec().using_encoded(blake2_256)
+	}
+
+	pub fn enum_to_vec() -> Vec<Vec<u8>> {
+		use crate::types::FruniqueRole::*;
+		[Owner.to_vec(), Admin.to_vec(), Collaborator.to_vec(), Collector.to_vec()].to_vec()
+	}
+}
+
+/// Extrinsics which require previous authorization to call them
+#[derive(
+	Encode, Decode, Clone, Eq, PartialEq, RuntimeDebugNoBound, MaxEncodedLen, TypeInfo, Copy,
+)]
+pub enum Permission {
+	/// No authorization required
+	None,
+	/// Authorization required
+	Required,
+	/// Authorization required and must be approved by the owner
+	Mint,
+	/// Authorization required and must be approved by a holder / collector
+	Transfer,
+}
+
+impl Permission {
+	pub fn to_vec(self) -> Vec<u8> {
+		match self {
+			Self::None => "None".as_bytes().to_vec(),
+			Self::Required => "Required".as_bytes().to_vec(),
+			Self::Mint => "Mint".as_bytes().to_vec(),
+			Self::Transfer => "Transfer".as_bytes().to_vec(),
+		}
+	}
+
+	pub fn id(&self) -> [u8; 32] {
+		self.to_vec().using_encoded(blake2_256)
+	}
+
+	pub fn admin_permissions() -> Vec<Vec<u8>> {
+		use crate::types::Permission::*;
+		let mut admin_permissions = [
+			None.to_vec(),
+			Required.to_vec(),
+			Mint.to_vec(),
+			Transfer.to_vec(),
+		]
+		.to_vec();
+		admin_permissions.append(&mut Permission::participant_permissions());
+		admin_permissions
+	}
+
+	pub fn participant_permissions() -> Vec<Vec<u8>> {
+		use crate::types::Permission::*;
+		[
+			None.to_vec(),
+			Required.to_vec(),
+			Transfer.to_vec(),
+		]
+		.to_vec()
+	}
 }