git.delta.rocks / unique-network / refs/commits / 9d5e6bdc297d

1// Copyright 2019-2022 Unique Network (Gibraltar) Ltd.2// This file is part of Unique Network.34// Unique Network is free software: you can redistribute it and/or modify5// it under the terms of the GNU General Public License as published by6// the Free Software Foundation, either version 3 of the License, or7// (at your option) any later version.89// Unique Network is distributed in the hope that it will be useful,10// but WITHOUT ANY WARRANTY; without even the implied warranty of11// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the12// GNU General Public License for more details.1314// You should have received a copy of the GNU General Public License15// along with Unique Network. If not, see <http://www.gnu.org/licenses/>.1617//! # RMRK Core Proxy Pallet18//!19//! A pallet used as proxy for RMRK Core (<https://rmrk-team.github.io/rmrk-substrate/#/pallets/rmrk-core>).20//!21//! - [`Config`]22//! - [`Call`]23//! - [`Pallet`]24//!25//! ## Overview26//!27//! The RMRK Equip Proxy pallet mirrors the functionality of RMRK Equip,28//! binding its externalities to Unique's own underlying structure.29//! It is purposed to mimic RMRK Equip exactly, allowing seamless integrations30//! of solutions based on RMRK.31//!32//! RMRK Equip itself contains functionality to equip NFTs, and work with Bases,33//! Parts, and Themes. See [Proxy Implementation](#proxy-implementation) for details.34//!35//! Equip Proxy is responsible for a more specific area of RMRK, and heavily relies on the Core.36//! For a more foundational description of proxy implementation, please refer to [`pallet_rmrk_core`].37//!38//! *Note*, that while RMRK itself is subject to active development and restructuring,39//! the proxy may be caught temporarily out of date.40//!41//! ### What is RMRK?42//!43//! RMRK is a set of NFT standards which compose several "NFT 2.0 lego" primitives.44//! Putting these legos together allows a user to create NFT systems of arbitrary complexity.45//!46//! Meaning, RMRK NFTs are dynamic, able to nest into each other and form a hierarchy,47//! make use of specific changeable and partially shared metadata in the form of resources,48//! and more.49//!50//! Visit RMRK documentation and repositories to learn more:51//! - Docs: <https://docs.rmrk.app/getting-started/>52//! - FAQ: <https://coda.io/@rmrk/faq>53//! - Substrate code repository: <https://github.com/rmrk-team/rmrk-substrate>54//! - RMRK spec repository: <https://github.com/rmrk-team/rmrk-spec>55//!56//! ## Terminology57//!58//! For more information on RMRK, see RMRK's own documentation.59//!60//! ### Intro to RMRK61//!62//! - **Resource:** Additional piece of metadata of an NFT usually serving to add63//! a piece of media on top of the root metadata (NFT's own), be it a different wing64//! on the root template bird or something entirely unrelated.65//!66//! - **Base:** A list of possible "components" - Parts, a combination of which can67//! be appended/equipped to/on an NFT.68//!69//! - **Part:** Something that, together with other Parts, can constitute an NFT.70//! Parts are defined in the Base to which they belong. Parts can be either71//! of the `slot` type or `fixed` type. Slots are intended for equippables.72//! Note that "part of something" and "Part of a Base" can be easily confused,73//! and so in this documentation these words are distinguished by the capital letter.74//!75//! - **Theme:** Named objects of variable => value pairs which get interpolated into76//! the Base's `themable` Parts. Themes can hold any value, but are often represented77//! in RMRK's examples as colors applied to visible Parts.78//!79//! ### Peculiarities in Unique80//!81//! - **Scoped properties:** Properties that are normally obscured from users.82//! Their purpose is to contain structured metadata that was not included in the Unique standard83//! for collections and tokens, meant to be operated on by proxies and other outliers.84//! Scoped property keys are prefixed with `some-scope:`, where `some-scope` is85//! an arbitrary keyword, like "rmrk". `:` is considered an unacceptable symbol in user-defined86//! properties, which, along with other safeguards, makes scoped ones impossible to tamper with.87//!88//! - **Auxiliary properties:** A slightly different structure of properties,89//! trading universality of use for more convenient storage, writes and access.90//! Meant to be inaccessible to end users.91//!92//! ## Proxy Implementation93//!94//! An external user is supposed to be able to utilize this proxy as they would95//! utilize RMRK, and get exactly the same results. Normally, Unique transactions96//! are off-limits to RMRK collections and tokens, and vice versa. However,97//! the information stored on chain can be freely interpreted by storage reads and Unique RPCs.98//!99//! ### ID Mapping100//!101//! RMRK's collections' IDs are counted independently of Unique's and start at 0.102//! Note that tokens' IDs still start at 1.103//! The collections themselves, as well as tokens, are stored as Unique collections,104//! and thus RMRK IDs are mapped to Unique IDs (but not vice versa).105//!106//! ### External/Internal Collection Insulation107//!108//! A Unique transaction cannot target collections purposed for RMRK,109//! and they are flagged as `external` to specify that. On the other hand,110//! due to the mapping, RMRK transactions and RPCs simply cannot reach Unique collections.111//!112//! ### Native Properties113//!114//! Many of RMRK's native parameters are stored as scoped properties of a collection115//! or an NFT on the chain. Scoped properties are prefixed with `rmrk:`, where `:`116//! is an unacceptable symbol in user-defined properties, which, along with other safeguards,117//! makes them impossible to tamper with.118//!119//! ### Collection and NFT Types, or Base, Parts and Themes Handling120//!121//! RMRK introduces the concept of a Base, which is a catalogue of Parts,122//! possible components of an NFT. Due to its similarity with the functionality123//! of a token collection, a Base is stored and handled as one, and the Base's Parts and Themes124//! are this collection's NFTs. See [`CollectionType`] and [`NftType`].125//!126//! ## Interface127//!128//! ### Dispatchables129//!130//! - `create_base` - Create a new Base.131//! - `theme_add` - Add a Theme to a Base.132//! - `equippable` - Update the array of Collections allowed to be equipped to a Base's specified Slot Part.133134#![cfg_attr(not(feature = "std"), no_std)]135136use frame_support::{pallet_prelude::*, BoundedVec, dispatch::DispatchResult};137use frame_system::{pallet_prelude::*, ensure_signed};138use sp_runtime::DispatchError;139use up_data_structs::*;140use pallet_common::{Pallet as PalletCommon, Error as CommonError};141use pallet_rmrk_core::{142	Pallet as PalletCore, Error as CoreError,143	misc::{self, *},144	property::RmrkProperty::*,145};146use pallet_nonfungible::{Pallet as PalletNft, NonfungibleHandle};147use pallet_evm::account::CrossAccountId;148use weights::WeightInfo;149150pub use pallet::*;151152#[cfg(feature = "runtime-benchmarks")]153pub mod benchmarking;154pub mod rpc;155pub mod weights;156157pub type SelfWeightOf<T> = <T as Config>::WeightInfo;158159#[frame_support::pallet]160pub mod pallet {161	use super::*;162163	#[pallet::config]164	pub trait Config: frame_system::Config + pallet_rmrk_core::Config {165		/// Overarching event type.166		type Event: From<Event<Self>> + IsType<<Self as frame_system::Config>::Event>;167168		/// The weight information of this pallet.169		type WeightInfo: WeightInfo;170	}171172	/// Map of a Base ID and a Part ID to an NFT in the Base collection serving as the Part.173	#[pallet::storage]174	#[pallet::getter(fn internal_part_id)]175	pub type InernalPartId<T: Config> =176		StorageDoubleMap<_, Twox64Concat, CollectionId, Twox64Concat, RmrkPartId, TokenId>;177178	/// Checkmark that a Base has a Theme NFT named "default".179	#[pallet::storage]180	#[pallet::getter(fn base_has_default_theme)]181	pub type BaseHasDefaultTheme<T: Config> =182		StorageMap<_, Twox64Concat, CollectionId, bool, ValueQuery>;183184	#[pallet::pallet]185	#[pallet::generate_store(pub(super) trait Store)]186	pub struct Pallet<T>(_);187188	#[pallet::event]189	#[pallet::generate_deposit(pub(super) fn deposit_event)]190	pub enum Event<T: Config> {191		BaseCreated {192			issuer: T::AccountId,193			base_id: RmrkBaseId,194		},195		EquippablesUpdated {196			base_id: RmrkBaseId,197			slot_id: RmrkSlotId,198		},199	}200201	#[pallet::error]202	pub enum Error<T> {203		/// No permission to perform action.204		PermissionError,205		/// Could not find an ID for a Base collection. It is likely there were too many collections created on the chain, causing an overflow.206		NoAvailableBaseId,207		/// Could not find a suitable ID for a Part, likely too many Part tokens were created in the Base, causing an overflow208		NoAvailablePartId,209		/// Base collection linked to this ID does not exist.210		BaseDoesntExist,211		/// No Theme named "default" is associated with the Base.212		NeedsDefaultThemeFirst,213		/// Part linked to this ID does not exist.214		PartDoesntExist,215		/// Cannot assign equippables to a fixed Part.216		NoEquippableOnFixedPart,217	}218219	#[pallet::call]220	impl<T: Config> Pallet<T> {221		/// Create a new Base.222		///223		/// Modeled after the [Base interaction](https://github.com/rmrk-team/rmrk-spec/blob/master/standards/rmrk2.0.0/interactions/base.md)224		///225		/// # Permissions226		/// - Anyone - will be assigned as the issuer of the Base.227		///228		/// # Arguments:229		/// - `origin`: Caller, will be assigned as the issuer of the Base230		/// - `base_type`: Arbitrary media type, e.g. "svg".231		/// - `symbol`: Arbitrary client-chosen symbol.232		/// - `parts`: Array of Fixed and Slot Parts composing the Base,233		/// confined in length by [`RmrkPartsLimit`](up_data_structs::RmrkPartsLimit).234		#[pallet::weight(<SelfWeightOf<T>>::create_base(parts.len() as u32))]235		pub fn create_base(236			origin: OriginFor<T>,237			base_type: RmrkString,238			symbol: RmrkBaseSymbol,239			parts: BoundedVec<RmrkPartType, RmrkPartsLimit>,240		) -> DispatchResult {241			let sender = ensure_signed(origin)?;242			let cross_sender = T::CrossAccountId::from_sub(sender.clone());243244			let data = CreateCollectionData {245				limits: None,246				token_prefix: symbol247					.into_inner()248					.try_into()249					.map_err(|_| <CommonError<T>>::CollectionTokenPrefixLimitExceeded)?,250				..Default::default()251			};252253			let collection_id_res = <PalletNft<T>>::init_collection(254				cross_sender.clone(),255				cross_sender.clone(),256				data,257				up_data_structs::CollectionFlags {258					external: true,259					..Default::default()260				},261			);262263			if let Err(DispatchError::Arithmetic(_)) = &collection_id_res {264				return Err(<Error<T>>::NoAvailableBaseId.into());265			}266267			let collection_id = collection_id_res?;268269			<PalletCommon<T>>::set_scoped_collection_properties(270				collection_id,271				PropertyScope::Rmrk,272				[273					<PalletCore<T>>::encode_rmrk_property(274						CollectionType,275						&misc::CollectionType::Base,276					)?,277					<PalletCore<T>>::encode_rmrk_property(BaseType, &base_type)?,278				]279				.into_iter(),280			)?;281282			let collection = <PalletCore<T>>::get_nft_collection(collection_id)?;283284			for part in parts {285				Self::create_part(&cross_sender, &collection, part)?;286			}287288			Self::deposit_event(Event::BaseCreated {289				issuer: sender,290				base_id: collection_id.0,291			});292293			Ok(())294		}295296		/// Add a Theme to a Base.297		/// A Theme named "default" is required prior to adding other Themes.298		///299		/// Modeled after [Themeadd interaction](https://github.com/rmrk-team/rmrk-spec/blob/master/standards/rmrk2.0.0/interactions/themeadd.md).300		///301		/// # Permissions:302		/// - Base issuer303		///304		/// # Arguments:305		/// - `origin`: sender of the transaction306		/// - `base_id`: Base ID containing the Theme to be updated.307		/// - `theme`: Theme to add to the Base.  A Theme has a name and properties, which are an308		///   array of [key, value, inherit].309		///   - `key`: Arbitrary BoundedString, defined by client.310		///   - `value`: Arbitrary BoundedString, defined by client.311		///   - `inherit`: Optional bool.312		#[pallet::weight(<SelfWeightOf<T>>::theme_add(theme.properties.len() as u32))]313		pub fn theme_add(314			origin: OriginFor<T>,315			base_id: RmrkBaseId,316			theme: RmrkBoundedTheme,317		) -> DispatchResult {318			let sender = ensure_signed(origin)?;319320			let sender = T::CrossAccountId::from_sub(sender);321			let owner = &sender;322323			let collection_id: CollectionId = base_id.into();324325			let collection = Self::get_base(collection_id)?;326327			if theme.name.as_slice() == b"default" {328				<BaseHasDefaultTheme<T>>::insert(collection_id, true);329			} else if !Self::base_has_default_theme(collection_id) {330				return Err(<Error<T>>::NeedsDefaultThemeFirst.into());331			}332333			let token_id = <PalletCore<T>>::create_nft(334				&sender,335				owner,336				&collection,337				[338					<PalletCore<T>>::encode_rmrk_property(TokenType, &NftType::Theme)?,339					<PalletCore<T>>::encode_rmrk_property(ThemeName, &theme.name)?,340					<PalletCore<T>>::encode_rmrk_property(ThemeInherit, &theme.inherit)?,341				]342				.into_iter(),343			)344			.map_err(|_| <Error<T>>::PermissionError)?;345346			for property in theme.properties {347				<PalletNft<T>>::set_scoped_token_property(348					collection_id,349					token_id,350					PropertyScope::Rmrk,351					<PalletCore<T>>::encode_rmrk_property(352						UserProperty(property.key.as_slice()),353						&property.value,354					)?,355				)?;356			}357358			Ok(())359		}360361		/// Update the array of Collections allowed to be equipped to a Base's specified Slot Part.362		///363		/// Modeled after [equippable interaction](https://github.com/rmrk-team/rmrk-spec/blob/master/standards/rmrk2.0.0/interactions/equippable.md).364		///365		/// # Permissions:366		/// - Base issuer367		///368		/// # Arguments:369		/// - `origin`: sender of the transaction370		/// - `base_id`: Base containing the Slot Part to be updated.371		/// - `slot_id`: Slot Part whose Equippable List is being updated .372		/// - `equippables`: List of equippables that will override the current Equippables list.373		#[pallet::weight(<SelfWeightOf<T>>::equippable())]374		pub fn equippable(375			origin: OriginFor<T>,376			base_id: RmrkBaseId,377			slot_id: RmrkSlotId,378			equippables: RmrkEquippableList,379		) -> DispatchResult {380			let sender = ensure_signed(origin)?;381382			let base_collection_id = base_id.into();383			let collection = Self::get_base(base_collection_id)?;384385			<PalletCore<T>>::check_collection_owner(386				&collection,387				&T::CrossAccountId::from_sub(sender),388			)389			.map_err(|err| {390				if err == <CoreError<T>>::NoPermission.into() {391					<Error<T>>::PermissionError.into()392				} else {393					err394				}395			})?;396397			let part_id = Self::internal_part_id(base_collection_id, slot_id)398				.ok_or(<Error<T>>::PartDoesntExist)?;399400			let nft_type = <PalletCore<T>>::get_nft_type(base_collection_id, part_id)401				.map_err(|_| <Error<T>>::PartDoesntExist)?;402403			match nft_type {404				NftType::Regular | NftType::Theme => return Err(<Error<T>>::PermissionError.into()),405				NftType::FixedPart => return Err(<Error<T>>::NoEquippableOnFixedPart.into()),406				NftType::SlotPart => {407					<PalletNft<T>>::set_scoped_token_property(408						base_collection_id,409						part_id,410						PropertyScope::Rmrk,411						<PalletCore<T>>::encode_rmrk_property(EquippableList, &equippables)?,412					)?;413				}414			}415416			Self::deposit_event(Event::EquippablesUpdated { base_id, slot_id });417418			Ok(())419		}420	}421}422423impl<T: Config> Pallet<T> {424	/// Create (or overwrite) a Part in a Base.425	/// The Part and the Base are represented as an NFT and a Collection.426	fn create_part(427		sender: &T::CrossAccountId,428		collection: &NonfungibleHandle<T>,429		part: RmrkPartType,430	) -> DispatchResult {431		let owner = sender;432433		let part_id = part.id();434		let src = part.src();435		let z_index = part.z_index();436437		let nft_type = match part {438			RmrkPartType::FixedPart(_) => NftType::FixedPart,439			RmrkPartType::SlotPart(_) => NftType::SlotPart,440		};441442		let token_id = match Self::internal_part_id(collection.id, part_id) {443			Some(token_id) => token_id,444			None => {445				let token_id =446					<PalletCore<T>>::create_nft(sender, owner, collection, [].into_iter())447						.map_err(|err| match err {448							DispatchError::Arithmetic(_) => <Error<T>>::NoAvailablePartId.into(),449							err => err,450						})?;451452				<InernalPartId<T>>::insert(collection.id, part_id, token_id);453454				<PalletNft<T>>::set_scoped_token_property(455					collection.id,456					token_id,457					PropertyScope::Rmrk,458					<PalletCore<T>>::encode_rmrk_property(ExternalPartId, &part_id)?,459				)?;460461				token_id462			}463		};464465		<PalletNft<T>>::set_scoped_token_properties(466			collection.id,467			token_id,468			PropertyScope::Rmrk,469			[470				<PalletCore<T>>::encode_rmrk_property(TokenType, &nft_type)?,471				<PalletCore<T>>::encode_rmrk_property(Src, &src)?,472				<PalletCore<T>>::encode_rmrk_property(ZIndex, &z_index)?,473			]474			.into_iter(),475		)?;476477		if let RmrkPartType::SlotPart(part) = part {478			<PalletNft<T>>::set_scoped_token_property(479				collection.id,480				token_id,481				PropertyScope::Rmrk,482				<PalletCore<T>>::encode_rmrk_property(EquippableList, &part.equippable)?,483			)?;484		}485486		Ok(())487	}488489	/// Ensure that the collection under the Base ID is a Base collection,490	/// and fetch it.491	fn get_base(base_id: CollectionId) -> Result<NonfungibleHandle<T>, DispatchError> {492		let collection =493			<PalletCore<T>>::get_typed_nft_collection(base_id, misc::CollectionType::Base)494				.map_err(|err| {495					if err == <CoreError<T>>::CollectionUnknown.into() {496						<Error<T>>::BaseDoesntExist.into()497					} else {498						err499					}500				})?;501		collection.check_is_external()?;502503		Ok(collection)504	}505}