`9e65253a1d22`

source

primitives/data-structs/src/rmrk.rs14.2 KiBsource history
1use codec::{Decode, Encode, MaxEncodedLen};2use scale_info::TypeInfo;345#[cfg(feature = "std")]6use serde::Serialize;78use primitives::*;910pub mod primitives {11	pub type CollectionId = u32;12	pub type ResourceId = u32;13	pub type NftId = u32;14	pub type BaseId = u32;15	pub type SlotId = u32;16	pub type PartId = u32;17	pub type ZIndex = u32;18}1920#[cfg(feature = "std")]21mod serialize {22    use core::convert::AsRef;23    use serde::ser::{self, Serialize};2425    pub mod vec {26        use super::*;2728        pub fn serialize<D, V, C>(value: &C, serializer: D) -> Result<D::Ok, D::Error>29        where30            D: ser::Serializer,31            V: Serialize,32            C: AsRef<[V]>,33        {34            value.as_ref().serialize(serializer)35        }36    }3738    pub mod opt_vec {39        use super::*;4041        pub fn serialize<D, V, C>(value: &Option<C>, serializer: D) -> Result<D::Ok, D::Error>42        where43            D: ser::Serializer,44            V: Serialize,45            C: AsRef<[V]>,46        {47            match value {48                Some(value) => super::vec::serialize(value, serializer),49                None => serializer.serialize_none()50            }51        }52    }53}5455/// Collection info.56#[cfg_attr(feature = "std", derive(PartialEq, Eq, Serialize))]57#[derive(Encode, Decode, Debug, TypeInfo, MaxEncodedLen)]58#[cfg_attr(59	feature = "std",60	serde(61		bound = r#"62			AccountId: Serialize,63			BoundedString: AsRef<[u8]>,64			BoundedSymbol: AsRef<[u8]>65		"#66	)67)]68pub struct CollectionInfo<BoundedString, BoundedSymbol, AccountId> {69	/// Current bidder and bid price.70	pub issuer: AccountId,7172	#[cfg_attr(feature = "std", serde(with = "serialize::vec"))]73	pub metadata: BoundedString,74	pub max: Option<u32>,7576	#[cfg_attr(feature = "std", serde(with = "serialize::vec"))]77	pub symbol: BoundedSymbol,78	pub nfts_count: u32,79}8081#[derive(Encode, Decode, Eq, PartialEq, Copy, Clone, Debug, TypeInfo, MaxEncodedLen)]82#[cfg_attr(feature = "std", derive(Serialize))]83pub enum AccountIdOrCollectionNftTuple<AccountId> {84	AccountId(AccountId),85	CollectionAndNftTuple(CollectionId, NftId),86}8788/// Royalty information (recipient and amount)89#[cfg_attr(feature = "std", derive(PartialEq, Eq, Serialize))]90#[derive(Encode, Decode, Debug, TypeInfo, MaxEncodedLen)]91pub struct RoyaltyInfo<AccountId, RoyaltyAmount> {92	/// Recipient (AccountId) of the royalty93    pub recipient: AccountId,94	/// Amount (Permill) of the royalty95    pub amount: RoyaltyAmount,96}9798/// Nft info.99#[cfg_attr(feature = "std", derive(PartialEq, Eq, Serialize))]100#[derive(Encode, Decode, Debug, TypeInfo, MaxEncodedLen)]101#[cfg_attr(102	feature = "std",103	serde(104		bound = r#"105			AccountId: Serialize,106			RoyaltyAmount: Serialize,107			BoundedString: AsRef<[u8]>108		"#109	)110)]111pub struct NftInfo<AccountId, RoyaltyAmount, BoundedString> {112	/// The owner of the NFT, can be either an Account or a tuple (CollectionId, NftId)113	pub owner: AccountIdOrCollectionNftTuple<AccountId>,114	/// Royalty (optional)115	pub royalty: Option<RoyaltyInfo<AccountId, RoyaltyAmount>>,116117	/// Arbitrary data about an instance, e.g. IPFS hash118	#[cfg_attr(feature = "std", serde(with = "serialize::vec"))]119	pub metadata: BoundedString,120121	/// Equipped state122	pub equipped: bool,123	/// Pending state (if sent to NFT)124	pub pending: bool,125}126127#[cfg_attr(feature = "std", derive(PartialEq, Eq, Serialize))]128#[derive(Encode, Decode, TypeInfo, MaxEncodedLen)]129pub struct NftChild {130	pub collection_id: CollectionId,131	pub nft_id: NftId132}133134#[cfg_attr(feature = "std", derive(Serialize))]135#[derive(Encode, Decode, PartialEq, TypeInfo)]136#[cfg_attr(137	feature = "std",138	serde(139		bound = r#"140			BoundedKey: AsRef<[u8]>,141			BoundedValue: AsRef<[u8]>142		"#143	)144)]145pub struct PropertyInfo<BoundedKey, BoundedValue>146{147	/// Key of the property148	#[cfg_attr(feature = "std", serde(with = "serialize::vec"))]149	pub key: BoundedKey,150151	/// Value of the property152	#[cfg_attr(feature = "std", serde(with = "serialize::vec"))]153	pub value: BoundedValue,154}155156#[derive(Encode, Decode, Eq, PartialEq, Clone, Debug, TypeInfo, MaxEncodedLen)]157#[cfg_attr(feature = "std", derive(Serialize))]158#[cfg_attr(159	feature = "std",160	serde(bound = "BoundedString: AsRef<[u8]>")161)]162pub struct BasicResource<BoundedString> {163	/// If the resource is Media, the base property is absent. Media src should be a URI like an164	/// IPFS hash.165	#[cfg_attr(feature = "std", serde(with = "serialize::opt_vec"))]166	pub src: Option<BoundedString>,167168	/// Reference to IPFS location of metadata169	#[cfg_attr(feature = "std", serde(with = "serialize::opt_vec"))]170	pub metadata: Option<BoundedString>,171172	/// Optional location or identier of license173	#[cfg_attr(feature = "std", serde(with = "serialize::opt_vec"))]174	pub license: Option<BoundedString>,175176	/// If the resource has the thumb property, this will be a URI to a thumbnail of the given177	/// resource. For example, if we have a composable NFT like a Kanaria bird, the resource is178	/// complex and too detailed to show in a search-results page or a list. Also, if a bird owns179	/// another bird, showing the full render of one bird inside the other's inventory might be a180	/// bit of a strain on the browser. For this reason, the thumb value can contain a URI to an181	/// image that is lighter and faster to load but representative of this resource.182	#[cfg_attr(feature = "std", serde(with = "serialize::opt_vec"))]183	pub thumb: Option<BoundedString>,184}185186#[derive(Encode, Decode, Eq, PartialEq, Clone, Debug, TypeInfo, MaxEncodedLen)]187#[cfg_attr(feature = "std", derive(Serialize))]188#[cfg_attr(189	feature = "std",190	serde(191		bound = r#"192			BoundedString: AsRef<[u8]>,193			BoundedParts: AsRef<[PartId]>194		"#195	)196)]197pub struct ComposableResource<BoundedString, BoundedParts> {198	/// If a resource is composed, it will have an array of parts that compose it199	#[cfg_attr(feature = "std", serde(with = "serialize::vec"))]200	pub parts: BoundedParts,201202	/// A Base is uniquely identified by the combination of the word `base`, its minting block203	/// number, and user provided symbol during Base creation, glued by dashes `-`, e.g.204	/// base-4477293-kanaria_superbird.205	pub base: BaseId,206207	/// If the resource is Media, the base property is absent. Media src should be a URI like an208	/// IPFS hash.209	#[cfg_attr(feature = "std", serde(with = "serialize::opt_vec"))]210	pub src: Option<BoundedString>,211212	/// Reference to IPFS location of metadata213	#[cfg_attr(feature = "std", serde(with = "serialize::opt_vec"))]214	pub metadata: Option<BoundedString>,215216	/// If the resource has the slot property, it was designed to fit into a specific Base's slot.217	/// The baseslot will be composed of two dot-delimited values, like so:218	/// "base-4477293-kanaria_superbird.machine_gun_scope". This means: "This resource is219	/// compatible with the machine_gun_scope slot of base base-4477293-kanaria_superbird220221	/// Optional location or identier of license222	#[cfg_attr(feature = "std", serde(with = "serialize::opt_vec"))]223	pub license: Option<BoundedString>,224225	/// If the resource has the thumb property, this will be a URI to a thumbnail of the given226	/// resource. For example, if we have a composable NFT like a Kanaria bird, the resource is227	/// complex and too detailed to show in a search-results page or a list. Also, if a bird owns228	/// another bird, showing the full render of one bird inside the other's inventory might be a229	/// bit of a strain on the browser. For this reason, the thumb value can contain a URI to an230	/// image that is lighter and faster to load but representative of this resource.231	#[cfg_attr(feature = "std", serde(with = "serialize::opt_vec"))]232	pub thumb: Option<BoundedString>,233}234235#[derive(Encode, Decode, Eq, PartialEq, Clone, Debug, TypeInfo, MaxEncodedLen)]236#[cfg_attr(feature = "std", derive(Serialize))]237#[cfg_attr(238	feature = "std",239	serde(bound = "BoundedString: AsRef<[u8]>")240)]241pub struct SlotResource<BoundedString> {242	/// A Base is uniquely identified by the combination of the word `base`, its minting block243	/// number, and user provided symbol during Base creation, glued by dashes `-`, e.g.244	/// base-4477293-kanaria_superbird.245	pub base: BaseId,246247	/// If the resource is Media, the base property is absent. Media src should be a URI like an248	/// IPFS hash.249	#[cfg_attr(feature = "std", serde(with = "serialize::opt_vec"))]250	pub src: Option<BoundedString>,251252	/// Reference to IPFS location of metadata253	#[cfg_attr(feature = "std", serde(with = "serialize::opt_vec"))]254	pub metadata: Option<BoundedString>,255256	/// If the resource has the slot property, it was designed to fit into a specific Base's slot.257	/// The baseslot will be composed of two dot-delimited values, like so:258	/// "base-4477293-kanaria_superbird.machine_gun_scope". This means: "This resource is259	/// compatible with the machine_gun_scope slot of base base-4477293-kanaria_superbird260	pub slot: SlotId,261262	/// The license field, if present, should contain a link to a license (IPFS or static HTTP263	/// url), or an identifier, like RMRK_nocopy or ipfs://ipfs/someHashOfLicense.264	#[cfg_attr(feature = "std", serde(with = "serialize::opt_vec"))]265	pub license: Option<BoundedString>,266267	/// If the resource has the thumb property, this will be a URI to a thumbnail of the given268	/// resource. For example, if we have a composable NFT like a Kanaria bird, the resource is269	/// complex and too detailed to show in a search-results page or a list. Also, if a bird owns270	/// another bird, showing the full render of one bird inside the other's inventory might be a271	/// bit of a strain on the browser. For this reason, the thumb value can contain a URI to an272	/// image that is lighter and faster to load but representative of this resource.273	#[cfg_attr(feature = "std", serde(with = "serialize::opt_vec"))]274	pub thumb: Option<BoundedString>,275}276277#[derive(Encode, Decode, Eq, PartialEq, Clone, Debug, TypeInfo, MaxEncodedLen)]278#[cfg_attr(feature = "std", derive(Serialize))]279#[cfg_attr(280	feature = "std",281	serde(282		bound = r#"283			BoundedString: AsRef<[u8]>,284			BoundedParts: AsRef<[PartId]>285		"#286	)287)]288pub enum ResourceTypes<BoundedString, BoundedParts> {289	Basic(BasicResource<BoundedString>),290	Composable(ComposableResource<BoundedString, BoundedParts>),291	Slot(SlotResource<BoundedString>),292}293294295#[derive(Encode, Decode, Eq, PartialEq, Clone, Debug, TypeInfo, MaxEncodedLen)]296#[cfg_attr(feature = "std", derive(Serialize))]297#[cfg_attr(298	feature = "std",299	serde(300		bound = r#"301			BoundedResource: AsRef<[u8]>,302			BoundedString: AsRef<[u8]>,303			BoundedParts: AsRef<[PartId]>304		"#305	)306)]307pub struct ResourceInfo<BoundedResource, BoundedString, BoundedParts> {308	/// id is a 5-character string of reasonable uniqueness.309	/// The combination of base ID and resource id should be unique across the entire RMRK310	/// ecosystem which311	#[cfg_attr(feature = "std", serde(with = "serialize::vec"))]312	pub id: BoundedResource,313314	/// Resource315	pub resource: ResourceTypes<BoundedString, BoundedParts>,316317	/// If resource is sent to non-rootowned NFT, pending will be false and need to be accepted318	pub pending: bool,319320	/// If resource removal request is sent by non-rootowned NFT, pending will be true and need to be accepted321	pub pending_removal: bool,322}323324#[cfg_attr(feature = "std", derive(PartialEq, Eq, Serialize))]325#[derive(Encode, Decode, Debug, TypeInfo, MaxEncodedLen)]326#[cfg_attr(327	feature = "std",328	serde(329		bound = r#"330			AccountId: Serialize,331			BoundedString: AsRef<[u8]>332		"#333	)334)]335pub struct BaseInfo<AccountId, BoundedString> {336	/// Original creator of the Base337	pub issuer: AccountId,338339	/// Specifies how an NFT should be rendered, ie "svg"340	#[cfg_attr(feature = "std", serde(with = "serialize::vec"))]341	pub base_type: BoundedString,342343	/// User provided symbol during Base creation344	#[cfg_attr(feature = "std", serde(with = "serialize::vec"))]345	pub symbol: BoundedString,346}347348#[cfg_attr(feature = "std", derive(Serialize))]349#[derive(Encode, Decode, Debug, TypeInfo, Clone, PartialEq, Eq, MaxEncodedLen)]350#[cfg_attr(351	feature = "std",352	serde(bound = "BoundedString: AsRef<[u8]>")353)]354pub struct FixedPart<BoundedString> {355	pub id: PartId,356	pub z: ZIndex,357358	#[cfg_attr(feature = "std", serde(with = "serialize::vec"))]359	pub src: BoundedString,360}361362#[cfg_attr(feature = "std", derive(Serialize))]363#[derive(Encode, Decode, Debug, Default, TypeInfo, Clone, PartialEq, Eq, MaxEncodedLen)]364#[cfg_attr(365	feature = "std",366	serde(bound = "BoundedCollectionList: AsRef<[CollectionId]>")367)]368pub enum EquippableList<BoundedCollectionList> {369	All,370	#[default] Empty,371	Custom(372		#[cfg_attr(feature = "std", serde(with = "serialize::vec"))]373		BoundedCollectionList374	),375}376377#[cfg_attr(feature = "std", derive(Serialize))]378#[derive(Encode, Decode, Debug, TypeInfo, Clone, PartialEq, Eq, MaxEncodedLen)]379#[cfg_attr(380	feature = "std",381	serde(382		bound = r#"383			BoundedString: AsRef<[u8]>,384			BoundedCollectionList: AsRef<[CollectionId]>385		"#386	)387)]388pub struct SlotPart<BoundedString, BoundedCollectionList> {389	pub id: PartId,390	pub equippable: EquippableList<BoundedCollectionList>,391392	#[cfg_attr(feature = "std", serde(with = "serialize::vec"))]393	pub src: BoundedString,394395	pub z: ZIndex,396}397398#[cfg_attr(feature = "std", derive(Serialize))]399#[derive(Encode, Decode, Debug, TypeInfo, Clone, PartialEq, Eq, MaxEncodedLen)]400#[cfg_attr(401	feature = "std",402	serde(403		bound = r#"404			BoundedString: AsRef<[u8]>,405			BoundedCollectionList: AsRef<[CollectionId]>406		"#407	)408)]409pub enum PartType<BoundedString, BoundedCollectionList> {410	FixedPart(FixedPart<BoundedString>),411	SlotPart(SlotPart<BoundedString, BoundedCollectionList>),412}413414#[cfg_attr(feature = "std", derive(Eq, Serialize))]415#[derive(Encode, Decode, Debug, TypeInfo, Clone, PartialEq)]416#[cfg_attr(417	feature = "std",418	serde(419		bound = r#"420			BoundedString: AsRef<[u8]>,421			PropertyList: AsRef<[ThemeProperty<BoundedString>]>,422		"#423	)424)]425pub struct Theme<BoundedString, PropertyList> {426	/// Name of the theme427	#[cfg_attr(feature = "std", serde(with = "serialize::vec"))]428	pub name: BoundedString,429430	/// Theme properties431	#[cfg_attr(feature = "std", serde(with = "serialize::vec"))]432	pub properties: PropertyList,433	/// Inheritability434	pub inherit: bool,435}436437#[cfg_attr(feature = "std", derive(Eq, Serialize))]438#[derive(Encode, Decode, Debug, TypeInfo, Clone, PartialEq)]439#[cfg_attr(440	feature = "std",441	serde(bound = "BoundedString: AsRef<[u8]>")442)]443pub struct ThemeProperty<BoundedString> {444	/// Key of the property445	#[cfg_attr(feature = "std", serde(with = "serialize::vec"))]446	pub key: BoundedString,447448	/// Value of the property449	#[cfg_attr(feature = "std", serde(with = "serialize::vec"))]450	pub value: BoundedString,451}