1#![cfg_attr(not(feature = "std"), no_std)]23use core::convert::{TryFrom, TryInto};45#[cfg(feature = "serde")]6pub use serde::{Serialize, Deserialize};78use sp_core::U256;9use sp_runtime::{ArithmeticError, sp_std::prelude::Vec};10use codec::{Decode, Encode, EncodeLike, MaxEncodedLen};11pub use frame_support::{12 BoundedVec, construct_runtime, decl_event, decl_module, decl_storage, decl_error,13 dispatch::DispatchResult,14 ensure, fail, parameter_types,15 traits::{16 Currency, ExistenceRequirement, Get, Imbalance, KeyOwnerProofSystem, OnUnbalanced,17 Randomness, IsSubType, WithdrawReasons,18 },19 weights::{20 constants::{BlockExecutionWeight, ExtrinsicBaseWeight, RocksDbWeight, WEIGHT_PER_SECOND},21 DispatchInfo, GetDispatchInfo, IdentityFee, Pays, PostDispatchInfo, Weight,22 WeightToFeePolynomial, DispatchClass,23 },24 StorageValue, transactional,25};26use derivative::Derivative;27use scale_info::TypeInfo;2829pub const MAX_DECIMAL_POINTS: DecimalPoints = 30;30pub const MAX_REFUNGIBLE_PIECES: u128 = 1_000_000_000_000_000_000_000;31pub const MAX_SPONSOR_TIMEOUT: u32 = 10_368_000;32pub const MAX_TOKEN_OWNERSHIP: u32 = 10_000_000;3334pub const COLLECTION_NUMBER_LIMIT: u32 = if cfg!(not(feature = "limit-testing")) {35 10000036} else {37 1038};39pub const CUSTOM_DATA_LIMIT: u32 = if cfg!(not(feature = "limit-testing")) {40 204841} else {42 1043};44pub const COLLECTION_ADMINS_LIMIT: u32 = 5;45pub const COLLECTION_TOKEN_LIMIT: u32 = u32::MAX;46pub const ACCOUNT_TOKEN_OWNERSHIP_LIMIT: u32 = if cfg!(not(feature = "limit-testing")) {47 100000048} else {49 1050};515253pub const NFT_SPONSOR_TRANSFER_TIMEOUT: u32 = 5;54pub const FUNGIBLE_SPONSOR_TRANSFER_TIMEOUT: u32 = 5;55pub const REFUNGIBLE_SPONSOR_TRANSFER_TIMEOUT: u32 = 5;565758pub const OFFCHAIN_SCHEMA_LIMIT: u32 = 1024;59pub const VARIABLE_ON_CHAIN_SCHEMA_LIMIT: u32 = 1024;60pub const CONST_ON_CHAIN_SCHEMA_LIMIT: u32 = 1024;6162pub const MAX_COLLECTION_NAME_LENGTH: usize = 64;63pub const MAX_COLLECTION_DESCRIPTION_LENGTH: usize = 256;64pub const MAX_TOKEN_PREFIX_LENGTH: usize = 16;65666768pub const MAX_ITEMS_PER_BATCH: u32 = 200;6970parameter_types! {71 pub const CustomDataLimit: u32 = CUSTOM_DATA_LIMIT;72}7374#[derive(Encode, Decode, PartialEq, Eq, PartialOrd, Ord, Clone, Copy, Debug, Default, TypeInfo)]75#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]76pub struct CollectionId(pub u32);77impl EncodeLike<u32> for CollectionId {}78impl EncodeLike<CollectionId> for u32 {}7980#[derive(Encode, Decode, PartialEq, Eq, PartialOrd, Ord, Clone, Copy, Debug, Default, TypeInfo)]81#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]82pub struct TokenId(pub u32);83impl EncodeLike<u32> for TokenId {}84impl EncodeLike<TokenId> for u32 {}8586impl TokenId {87 pub fn try_next(self) -> Result<TokenId, ArithmeticError> {88 self.089 .checked_add(1)90 .ok_or(ArithmeticError::Overflow)91 .map(Self)92 }93}9495impl From<TokenId> for U256 {96 fn from(t: TokenId) -> Self {97 t.0.into()98 }99}100101impl TryFrom<U256> for TokenId {102 type Error = &'static str;103104 fn try_from(value: U256) -> Result<Self, Self::Error> {105 Ok(TokenId(value.try_into().map_err(|_| "too large token id")?))106 }107}108109pub struct OverflowError;110impl From<OverflowError> for &'static str {111 fn from(_: OverflowError) -> Self {112 "overflow occured"113 }114}115116pub type DecimalPoints = u8;117118#[derive(Encode, Decode, Eq, Debug, Clone, PartialEq, TypeInfo)]119#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]120pub enum CollectionMode {121 NFT,122 123 Fungible(DecimalPoints),124 ReFungible,125}126127impl CollectionMode {128 pub fn id(&self) -> u8 {129 match self {130 CollectionMode::NFT => 1,131 CollectionMode::Fungible(_) => 2,132 CollectionMode::ReFungible => 3,133 }134 }135}136137pub trait SponsoringResolve<AccountId, Call> {138 fn resolve(who: &AccountId, call: &Call) -> Option<AccountId>;139}140141#[derive(Encode, Decode, Eq, Debug, Clone, PartialEq, TypeInfo)]142#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]143pub enum AccessMode {144 Normal,145 AllowList,146}147impl Default for AccessMode {148 fn default() -> Self {149 Self::Normal150 }151}152153#[derive(Encode, Decode, Eq, Debug, Clone, PartialEq, TypeInfo)]154#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]155pub enum SchemaVersion {156 ImageURL,157 Unique,158}159impl Default for SchemaVersion {160 fn default() -> Self {161 Self::ImageURL162 }163}164165#[derive(Encode, Decode, Default, Debug, Clone, PartialEq, TypeInfo)]166#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]167pub struct Ownership<AccountId> {168 pub owner: AccountId,169 pub fraction: u128,170}171172#[derive(Encode, Decode, Debug, Clone, PartialEq, TypeInfo)]173#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]174pub enum SponsorshipState<AccountId> {175 176 Disabled,177 Unconfirmed(AccountId),178 179 Confirmed(AccountId),180}181182impl<AccountId> SponsorshipState<AccountId> {183 pub fn sponsor(&self) -> Option<&AccountId> {184 match self {185 Self::Confirmed(sponsor) => Some(sponsor),186 _ => None,187 }188 }189190 pub fn pending_sponsor(&self) -> Option<&AccountId> {191 match self {192 Self::Unconfirmed(sponsor) | Self::Confirmed(sponsor) => Some(sponsor),193 _ => None,194 }195 }196197 pub fn confirmed(&self) -> bool {198 matches!(self, Self::Confirmed(_))199 }200}201202impl<T> Default for SponsorshipState<T> {203 fn default() -> Self {204 Self::Disabled205 }206}207208#[derive(Encode, Decode, Clone, PartialEq, TypeInfo)]209#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]210pub struct Collection<AccountId> {211 pub owner: AccountId,212 pub mode: CollectionMode,213 pub access: AccessMode,214 pub name: Vec<u16>, 215 pub description: Vec<u16>, 216 pub token_prefix: Vec<u8>, 217 pub mint_mode: bool,218 pub offchain_schema: Vec<u8>,219 pub schema_version: SchemaVersion,220 pub sponsorship: SponsorshipState<AccountId>,221 pub limits: CollectionLimits, 222 pub variable_on_chain_schema: Vec<u8>, 223 pub const_on_chain_schema: Vec<u8>, 224 pub meta_update_permission: MetaUpdatePermission,225}226227#[derive(Encode, Decode, Debug, Clone, PartialEq, TypeInfo)]228#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]229pub struct NftItemType<AccountId> {230 pub owner: AccountId,231 pub const_data: Vec<u8>,232 pub variable_data: Vec<u8>,233}234235#[derive(Encode, Decode, Default, Debug, Clone, PartialEq, TypeInfo)]236#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]237pub struct FungibleItemType {238 pub value: u128,239}240241#[derive(Encode, Decode, Debug, Clone, PartialEq, TypeInfo)]242#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]243pub struct ReFungibleItemType<AccountId> {244 pub owner: Vec<Ownership<AccountId>>,245 pub const_data: Vec<u8>,246 pub variable_data: Vec<u8>,247}248249#[derive(Encode, Decode, Debug, Default, Clone, PartialEq, TypeInfo)]250#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]251pub struct CollectionLimits {252 pub account_token_ownership_limit: Option<u32>,253 pub sponsored_data_size: Option<u32>,254 255 256 257 pub sponsored_data_rate_limit: Option<u32>,258 pub token_limit: Option<u32>,259260 261 pub sponsor_transfer_timeout: Option<u32>,262 pub owner_can_transfer: Option<bool>,263 pub owner_can_destroy: Option<bool>,264 pub transfers_enabled: Option<bool>,265}266267impl CollectionLimits {268 pub fn account_token_ownership_limit(&self) -> u32 {269 self.account_token_ownership_limit270 .unwrap_or(ACCOUNT_TOKEN_OWNERSHIP_LIMIT)271 .min(MAX_TOKEN_OWNERSHIP)272 }273 pub fn sponsored_data_size(&self) -> u32 {274 self.sponsored_data_size275 .unwrap_or(CUSTOM_DATA_LIMIT)276 .min(CUSTOM_DATA_LIMIT)277 }278 pub fn token_limit(&self) -> u32 {279 self.token_limit280 .unwrap_or(COLLECTION_TOKEN_LIMIT)281 .min(COLLECTION_TOKEN_LIMIT)282 }283 pub fn sponsor_transfer_timeout(&self, default: u32) -> u32 {284 self.sponsor_transfer_timeout285 .unwrap_or(default)286 .min(MAX_SPONSOR_TIMEOUT)287 }288 pub fn owner_can_transfer(&self) -> bool {289 self.owner_can_transfer.unwrap_or(true)290 }291 pub fn owner_can_destroy(&self) -> bool {292 self.owner_can_destroy.unwrap_or(true)293 }294 pub fn transfers_enabled(&self) -> bool {295 self.transfers_enabled.unwrap_or(true)296 }297 pub fn sponsored_data_rate_limit(&self) -> Option<u32> {298 self.sponsored_data_rate_limit299 .map(|v| v.min(MAX_SPONSOR_TIMEOUT))300 }301}302303304#[cfg(feature = "serde1")]305mod bounded_serde {306 use core::convert::TryFrom;307 use frame_support::{BoundedVec, traits::Get};308 use serde::{309 ser::{self, Serialize},310 de::{self, Deserialize, Error},311 };312 use sp_std::vec::Vec;313314 pub fn serialize<D, V, S>(value: &BoundedVec<V, S>, serializer: D) -> Result<D::Ok, D::Error>315 where316 D: ser::Serializer,317 V: Serialize,318 {319 let vec: &Vec<_> = &value;320 vec.serialize(serializer)321 }322323 pub fn deserialize<'de, D, V, S>(deserializer: D) -> Result<BoundedVec<V, S>, D::Error>324 where325 D: de::Deserializer<'de>,326 V: de::Deserialize<'de>,327 S: Get<u32>,328 {329 330 let vec = <Vec<V>>::deserialize(deserializer)?;331 let len = vec.len();332 TryFrom::try_from(vec).map_err(|_| D::Error::invalid_length(len, &"lesser size"))333 }334}335336#[derive(Encode, Decode, MaxEncodedLen, Default, PartialEq, Clone, Derivative, TypeInfo)]337#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]338#[derivative(Debug)]339pub struct CreateNftData {340 #[cfg_attr(feature = "serde1", serde(with = "bounded_serde"))]341 #[derivative(Debug = "ignore")]342 pub const_data: BoundedVec<u8, CustomDataLimit>,343 #[cfg_attr(feature = "serde1", serde(with = "bounded_serde"))]344 #[derivative(Debug = "ignore")]345 pub variable_data: BoundedVec<u8, CustomDataLimit>,346}347348#[derive(Encode, Decode, MaxEncodedLen, Default, Debug, Clone, PartialEq, TypeInfo)]349#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]350pub struct CreateFungibleData {351 pub value: u128,352}353354#[derive(Encode, Decode, MaxEncodedLen, Default, PartialEq, Clone, Derivative, TypeInfo)]355#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]356#[derivative(Debug)]357pub struct CreateReFungibleData {358 #[cfg_attr(feature = "serde1", serde(with = "bounded_serde"))]359 #[derivative(Debug = "ignore")]360 pub const_data: BoundedVec<u8, CustomDataLimit>,361 #[cfg_attr(feature = "serde1", serde(with = "bounded_serde"))]362 #[derivative(Debug = "ignore")]363 pub variable_data: BoundedVec<u8, CustomDataLimit>,364 pub pieces: u128,365}366367#[derive(Encode, Decode, Debug, Clone, PartialEq, TypeInfo)]368#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]369pub enum MetaUpdatePermission {370 ItemOwner,371 Admin,372 None,373}374375impl Default for MetaUpdatePermission {376 fn default() -> Self {377 Self::ItemOwner378 }379}380381#[derive(Encode, Decode, MaxEncodedLen, PartialEq, Clone, Debug, TypeInfo)]382#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]383pub enum CreateItemData {384 NFT(CreateNftData),385 Fungible(CreateFungibleData),386 ReFungible(CreateReFungibleData),387}388389impl CreateItemData {390 pub fn data_size(&self) -> usize {391 match self {392 CreateItemData::NFT(data) => data.variable_data.len() + data.const_data.len(),393 CreateItemData::ReFungible(data) => data.variable_data.len() + data.const_data.len(),394 _ => 0,395 }396 }397}398399impl From<CreateNftData> for CreateItemData {400 fn from(item: CreateNftData) -> Self {401 CreateItemData::NFT(item)402 }403}404405impl From<CreateReFungibleData> for CreateItemData {406 fn from(item: CreateReFungibleData) -> Self {407 CreateItemData::ReFungible(item)408 }409}410411impl From<CreateFungibleData> for CreateItemData {412 fn from(item: CreateFungibleData) -> Self {413 CreateItemData::Fungible(item)414 }415}416417#[derive(Encode, Decode, MaxEncodedLen, PartialEq, Clone, Debug, TypeInfo)]418#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]419pub struct CollectionStats {420 pub created: u32,421 pub destroyed: u32,422 pub alive: u32,423}