difftreelog
refactor extract contracts logic to separate pallet
in: master
2 files changed
pallets/contract-helpers/src/lib.rsdiffbeforeafterboth--- /dev/null
+++ b/pallets/contract-helpers/src/lib.rs
@@ -0,0 +1,230 @@
+#![cfg_attr(not(feature = "std"), no_std)]
+
+pub use pallet::*;
+
+#[frame_support::pallet]
+pub mod pallet {
+ use frame_support::sp_runtime::traits::StaticLookup;
+ use frame_support::{pallet_prelude::*, traits::IsSubType};
+ use frame_system::pallet_prelude::*;
+ use pallet_contracts::chain_extension::UncheckedFrom;
+ use sp_runtime::{
+ traits::{DispatchInfoOf, Hash, PostDispatchInfoOf, SignedExtension},
+ transaction_validity,
+ };
+ use sp_std::vec::Vec;
+ use up_sponsorship::SponsorshipHandler;
+
+ #[pallet::error]
+ pub enum Error<T> {
+ /// Should be contract owner
+ NoPermission,
+ }
+
+ #[pallet::config]
+ pub trait Config: frame_system::Config + pallet_contracts::Config {}
+
+ #[pallet::pallet]
+ #[pallet::generate_store(pub(super) trait Store)]
+ pub struct Pallet<T>(_);
+
+ #[pallet::storage]
+ pub(super) type Owner<T: Config> = StorageMap<
+ Hasher = Twox128,
+ Key = T::AccountId,
+ Value = T::AccountId,
+ QueryKind = ValueQuery,
+ >;
+
+ #[pallet::storage]
+ pub(super) type AllowlistEnabled<T: Config> =
+ StorageMap<Hasher = Twox128, Key = T::AccountId, Value = bool, QueryKind = ValueQuery>;
+
+ #[pallet::storage]
+ pub(super) type Allowlist<T: Config> = StorageDoubleMap<
+ Hasher1 = Twox128,
+ Key1 = T::AccountId,
+ Hasher2 = Twox64Concat,
+ Key2 = T::AccountId,
+ Value = bool,
+ QueryKind = ValueQuery,
+ >;
+
+ #[pallet::storage]
+ pub(super) type SelfSponsoring<T: Config> =
+ StorageMap<Hasher = Twox128, Key = T::AccountId, Value = bool, QueryKind = ValueQuery>;
+
+ #[pallet::storage]
+ pub(super) type SponsoringRateLimit<T: Config> = StorageMap<
+ Hasher = Twox128,
+ Key = T::AccountId,
+ Value = T::BlockNumber,
+ QueryKind = ValueQuery,
+ >;
+
+ #[pallet::storage]
+ pub(super) type SponsorBasket<T: Config> = StorageDoubleMap<
+ Hasher1 = Twox128,
+ Key1 = T::AccountId,
+ Hasher2 = Twox128,
+ Key2 = T::AccountId,
+ Value = T::BlockNumber,
+ QueryKind = ValueQuery,
+ >;
+
+ #[pallet::call]
+ impl<T: Config> Pallet<T> {
+ #[pallet::weight(0)]
+ fn toggle_sponsoring(
+ origin: OriginFor<T>,
+ contract: T::AccountId,
+ sponsoring: bool,
+ ) -> DispatchResult {
+ let sender = ensure_signed(origin)?;
+ ensure!(<Owner<T>>::get(&contract) == sender, <Error<T>>::NoPermission);
+
+ if sponsoring {
+ <SelfSponsoring<T>>::insert(contract, true);
+ } else {
+ <SelfSponsoring<T>>::remove(contract);
+ }
+ Ok(())
+ }
+
+ #[pallet::weight(0)]
+ fn toggle_allowlist(
+ origin: OriginFor<T>,
+ contract: T::AccountId,
+ enabled: bool,
+ ) -> DispatchResult {
+ let sender = ensure_signed(origin)?;
+ ensure!(<Owner<T>>::get(&contract) == sender, <Error<T>>::NoPermission);
+
+ if enabled {
+ <AllowlistEnabled<T>>::insert(contract, true);
+ } else {
+ <AllowlistEnabled<T>>::remove(contract);
+ }
+ Ok(())
+ }
+
+ #[pallet::weight(0)]
+ fn toggle_allowed(
+ origin: OriginFor<T>,
+ contract: T::AccountId,
+ user: T::AccountId,
+ allowed: bool,
+ ) -> DispatchResult {
+ let sender = ensure_signed(origin)?;
+ ensure!(<Owner<T>>::get(&contract) == sender, <Error<T>>::NoPermission);
+
+ if allowed {
+ <Allowlist<T>>::insert(contract, user, true);
+ } else {
+ <Allowlist<T>>::remove(contract, user);
+ }
+ Ok(())
+ }
+
+ #[pallet::weight(0)]
+ fn set_sponsoring_rate_limit(
+ origin: OriginFor<T>,
+ contract: T::AccountId,
+ rate_limit: T::BlockNumber,
+ ) -> DispatchResult {
+ let sender = ensure_signed(origin)?;
+ ensure!(<Owner<T>>::get(&contract) == sender, <Error<T>>::NoPermission);
+
+ <SponsoringRateLimit<T>>::insert(contract, rate_limit);
+ Ok(())
+ }
+ }
+
+ #[derive(Encode, Decode, Clone, PartialEq, Eq)]
+ pub struct ContractHelpersExtension<T>(PhantomData<T>);
+ impl<T> core::fmt::Debug for ContractHelpersExtension<T> {
+ fn fmt(&self, fmt: &mut core::fmt::Formatter<'_>) -> Result<(), core::fmt::Error> {
+ fmt.debug_struct("ContractHelpersExtension").finish()
+ }
+ }
+
+ type CodeHash<T> = <T as frame_system::Config>::Hash;
+ impl<T> SignedExtension for ContractHelpersExtension<T>
+ where
+ T: Config + Send + Sync,
+ T::Call: sp_runtime::traits::Dispatchable,
+ T::Call: IsSubType<pallet_contracts::Call<T>>,
+ T::AccountId: UncheckedFrom<T::Hash>,
+ T::AccountId: AsRef<[u8]>,
+ {
+ const IDENTIFIER: &'static str = "ContractHelpers";
+ type AccountId = T::AccountId;
+ type Call = T::Call;
+ type AdditionalSigned = ();
+ type Pre = Option<(Self::AccountId, CodeHash<T>, Vec<u8>)>;
+
+ fn additional_signed(&self) -> Result<(), transaction_validity::TransactionValidityError> {
+ Ok(())
+ }
+
+ fn validate(
+ &self,
+ who: &T::AccountId,
+ call: &Self::Call,
+ _info: &DispatchInfoOf<Self::Call>,
+ _len: usize,
+ ) -> transaction_validity::TransactionValidity {
+ match IsSubType::<pallet_contracts::Call<T>>::is_sub_type(call) {
+ Some(pallet_contracts::Call::call(dest, _value, _gas_limit, _data)) => {
+ let called_contract: T::AccountId =
+ T::Lookup::lookup((*dest).clone()).unwrap_or(T::AccountId::default());
+ if <AllowlistEnabled<T>>::get(&called_contract) {
+ if !<Allowlist<T>>::get(&called_contract, who)
+ && &<Owner<T>>::get(&called_contract) != who
+ {
+ return Err(transaction_validity::InvalidTransaction::Call.into());
+ }
+ }
+ }
+ _ => {}
+ }
+ Ok(transaction_validity::ValidTransaction::default())
+ }
+
+ fn pre_dispatch(
+ self,
+ who: &Self::AccountId,
+ call: &Self::Call,
+ _info: &DispatchInfoOf<Self::Call>,
+ _len: usize,
+ ) -> Result<Self::Pre, TransactionValidityError> {
+ match IsSubType::<pallet_contracts::Call<T>>::is_sub_type(call) {
+ Some(pallet_contracts::Call::instantiate(_, _, code_hash, _, salt)) => {
+ Ok(Some((who.clone(), code_hash.clone(), salt.clone())))
+ }
+ Some(pallet_contracts::Call::instantiate_with_code(_, _, code, _, salt)) => {
+ let code_hash = &T::Hashing::hash(&code);
+ Ok(Some((who.clone(), code_hash.clone(), salt.clone())))
+ }
+ _ => Ok(None),
+ }
+ }
+
+ fn post_dispatch(
+ pre: Self::Pre,
+ _info: &DispatchInfoOf<Self::Call>,
+ _post_info: &PostDispatchInfoOf<Self::Call>,
+ _len: usize,
+ _result: &DispatchResult,
+ ) -> Result<(), TransactionValidityError> {
+ if let Some((who, code_hash, salt)) = pre {
+ let new_contract_address =
+ <pallet_contracts::Pallet<T>>::contract_address(&who, &code_hash, &salt);
+ <Owner<T>>::insert(&new_contract_address, &who);
+ }
+
+ Ok(())
+ }
+ }
+
+}
pallets/nft/src/lib.rsdiffbeforeafterboth1//2// This file is subject to the terms and conditions defined in3// file 'LICENSE', which is part of this source code package.4//56#![recursion_limit = "1024"]78#![cfg_attr(not(feature = "std"), no_std)]910extern crate alloc;1112pub use serde::{Serialize, Deserialize};1314pub use frame_support::{15 construct_runtime, decl_event, decl_module, decl_storage, decl_error,16 dispatch::DispatchResult,17 ensure, fail, parameter_types,18 traits::{19 Currency, ExistenceRequirement, Get, Imbalance, KeyOwnerProofSystem, OnUnbalanced,20 Randomness, IsSubType, WithdrawReasons,21 },22 weights::{23 constants::{BlockExecutionWeight, ExtrinsicBaseWeight, RocksDbWeight, WEIGHT_PER_SECOND},24 DispatchInfo, GetDispatchInfo, IdentityFee, Pays, PostDispatchInfo, Weight,25 WeightToFeePolynomial, DispatchClass,26 },27 StorageValue,28 transactional,29};3031use frame_system::{self as system, ensure_signed, ensure_root};32use sp_core::H160;33use sp_runtime::sp_std::prelude::Vec;34use core::ops::{Deref, DerefMut};35use core::cell::RefCell;36use nft_data_structs::{37 MAX_DECIMAL_POINTS, MAX_SPONSOR_TIMEOUT, MAX_TOKEN_OWNERSHIP, MAX_REFUNGIBLE_PIECES,38 AccessMode, ChainLimits, Collection, CreateItemData, CollectionLimits,39 CollectionId, CollectionMode, TokenId, 40 SchemaVersion, SponsorshipState, Ownership,41 NftItemType, FungibleItemType, ReFungibleItemType42};43use pallet_ethereum::EthereumTransactionSender;4445#[cfg(test)]46mod mock;4748#[cfg(test)]49mod tests;5051mod default_weights;52mod eth;5354pub use eth::NftErcSupport;55pub use eth::account::*;56use eth::erc::{ERC20Events, ERC721Events};5758#[cfg(feature = "runtime-benchmarks")]59mod benchmarking;6061pub trait WeightInfo {62 fn create_collection() -> Weight;63 fn destroy_collection() -> Weight;64 fn add_to_white_list() -> Weight;65 fn remove_from_white_list() -> Weight;66 fn set_public_access_mode() -> Weight;67 fn set_mint_permission() -> Weight;68 fn change_collection_owner() -> Weight;69 fn add_collection_admin() -> Weight;70 fn remove_collection_admin() -> Weight;71 fn set_collection_sponsor() -> Weight;72 fn confirm_sponsorship() -> Weight;73 fn remove_collection_sponsor() -> Weight;74 fn create_item(s: usize) -> Weight;75 fn burn_item() -> Weight;76 fn transfer() -> Weight;77 fn approve() -> Weight;78 fn transfer_from() -> Weight;79 fn set_offchain_schema() -> Weight;80 fn set_const_on_chain_schema() -> Weight;81 fn set_variable_on_chain_schema() -> Weight;82 fn set_variable_meta_data() -> Weight;83 fn enable_contract_sponsoring() -> Weight;84 fn set_schema_version() -> Weight;85 fn set_chain_limits() -> Weight;86 fn set_contract_sponsoring_rate_limit() -> Weight;87 fn set_variable_meta_data_sponsoring_rate_limit() -> Weight;88 fn toggle_contract_white_list() -> Weight;89 fn add_to_contract_white_list() -> Weight;90 fn remove_from_contract_white_list() -> Weight;91 fn set_collection_limits() -> Weight;92}9394decl_error! {95 /// Error for non-fungible-token module.96 pub enum Error for Module<T: Config> {97 /// Total collections bound exceeded.98 TotalCollectionsLimitExceeded,99 /// Decimal_points parameter must be lower than MAX_DECIMAL_POINTS constant, currently it is 30.100 CollectionDecimalPointLimitExceeded, 101 /// Collection name can not be longer than 63 char.102 CollectionNameLimitExceeded, 103 /// Collection description can not be longer than 255 char.104 CollectionDescriptionLimitExceeded, 105 /// Token prefix can not be longer than 15 char.106 CollectionTokenPrefixLimitExceeded,107 /// This collection does not exist.108 CollectionNotFound,109 /// Item not exists.110 TokenNotFound,111 /// Admin not found112 AdminNotFound,113 /// Arithmetic calculation overflow.114 NumOverflow, 115 /// Account already has admin role.116 AlreadyAdmin, 117 /// You do not own this collection.118 NoPermission,119 /// This address is not set as sponsor, use setCollectionSponsor first.120 ConfirmUnsetSponsorFail,121 /// Collection is not in mint mode.122 PublicMintingNotAllowed,123 /// Sender parameter and item owner must be equal.124 MustBeTokenOwner,125 /// Item balance not enough.126 TokenValueTooLow,127 /// Size of item is too large.128 NftSizeLimitExceeded,129 /// No approve found130 ApproveNotFound,131 /// Requested value more than approved.132 TokenValueNotEnough,133 /// Only approved addresses can call this method.134 ApproveRequired,135 /// Address is not in white list.136 AddresNotInWhiteList,137 /// Number of collection admins bound exceeded.138 CollectionAdminsLimitExceeded,139 /// Owned tokens by a single address bound exceeded.140 AddressOwnershipLimitExceeded,141 /// Length of items properties must be greater than 0.142 EmptyArgument,143 /// const_data exceeded data limit.144 TokenConstDataLimitExceeded,145 /// variable_data exceeded data limit.146 TokenVariableDataLimitExceeded,147 /// Not NFT item data used to mint in NFT collection.148 NotNftDataUsedToMintNftCollectionToken,149 /// Not Fungible item data used to mint in Fungible collection.150 NotFungibleDataUsedToMintFungibleCollectionToken,151 /// Not Re Fungible item data used to mint in Re Fungible collection.152 NotReFungibleDataUsedToMintReFungibleCollectionToken,153 /// Unexpected collection type.154 UnexpectedCollectionType,155 /// Can't store metadata in fungible tokens.156 CantStoreMetadataInFungibleTokens,157 /// Collection token limit exceeded158 CollectionTokenLimitExceeded,159 /// Account token limit exceeded per collection160 AccountTokenLimitExceeded,161 /// Collection limit bounds per collection exceeded162 CollectionLimitBoundsExceeded,163 /// Tried to enable permissions which are only permitted to be disabled164 OwnerPermissionsCantBeReverted,165 /// Schema data size limit bound exceeded166 SchemaDataLimitExceeded,167 /// Maximum refungibility exceeded168 WrongRefungiblePieces,169 /// createRefungible should be called with one owner170 BadCreateRefungibleCall,171 /// Gas limit exceeded172 OutOfGas,173 }174}175176pub struct CollectionHandle<T: Config> {177 pub id: CollectionId,178 collection: Collection<T>,179 logs: eth::log::LogRecorder,180 evm_address: H160,181 gas_limit: RefCell<u64>,182}183impl<T: Config> CollectionHandle<T> {184 pub fn get_with_gas_limit(id: CollectionId, gas_limit: u64) -> Option<Self> {185 <CollectionById<T>>::get(id)186 .map(|collection| Self {187 id,188 collection,189 logs: eth::log::LogRecorder::default(),190 evm_address: eth::collection_id_to_address(id),191 gas_limit: RefCell::new(gas_limit),192 })193 }194 pub fn get(id: CollectionId) -> Option<Self> {195 Self::get_with_gas_limit(id, u64::MAX)196 }197 pub fn gas_left(&self) -> u64 {198 *self.gas_limit.borrow()199 }200 pub fn consume_gas(&self, gas: u64) -> DispatchResult {201 let mut gas_limit = self.gas_limit.borrow_mut();202 if *gas_limit < gas {203 fail!(Error::<T>::OutOfGas);204 }205 *gas_limit -= gas;206 Ok(())207 }208 pub fn log(&self, log: impl evm_coder::ToLog) {209 self.logs.log(log.to_log(self.evm_address))210 }211 pub fn into_inner(self) -> Collection<T> {212 self.collection.clone()213 }214}215impl<T: Config> Deref for CollectionHandle<T> {216 type Target = Collection<T>;217218 fn deref(&self) -> &Self::Target {219 &self.collection220 }221}222223impl<T: Config> DerefMut for CollectionHandle<T> {224 fn deref_mut(&mut self) -> &mut Self::Target {225 &mut self.collection226 }227}228229pub trait Config: system::Config + Sized {230 type Event: From<Event<Self>> + Into<<Self as system::Config>::Event>;231232 /// Weight information for extrinsics in this pallet.233 type WeightInfo: WeightInfo;234235 type EvmAddressMapping: pallet_evm::AddressMapping<Self::AccountId>;236 type EvmBackwardsAddressMapping: EvmBackwardsAddressMapping<Self::AccountId>;237 type EvmWithdrawOrigin: pallet_evm::EnsureAddressOrigin<Self::Origin, Success = Self::AccountId>;238239 type CrossAccountId: CrossAccountId<Self::AccountId>;240 type Currency: Currency<Self::AccountId>;241 type CollectionCreationPrice: Get<<<Self as Config>::Currency as Currency<Self::AccountId>>::Balance>;242 type TreasuryAccountId: Get<Self::AccountId>;243244 type EthereumChainId: Get<u64>;245 type EthereumTransactionSender: pallet_ethereum::EthereumTransactionSender;246}247248// # Used definitions249//250// ## User control levels251//252// chain-controlled - key is uncontrolled by user253// i.e autoincrementing index254// can use non-cryptographic hash255// real - key is controlled by user256// but it is hard to generate enough colliding values, i.e owner of signed txs257// can use non-cryptographic hash258// controlled - key is completly controlled by users259// i.e maps with mutable keys260// should use cryptographic hash261//262// ## User control level downgrade reasons263//264// ?1 - chain-controlled -> controlled265// collections/tokens can be destroyed, resulting in massive holes266// ?2 - chain-controlled -> controlled267// same as ?1, but can be only added, resulting in easier exploitation268// ?3 - real -> controlled269// no confirmation required, so addresses can be easily generated270decl_storage! {271 trait Store for Module<T: Config> as Nft {272273 //#region Private members274 /// Id of next collection275 CreatedCollectionCount: u32;276 /// Used for migrations277 ChainVersion: u64;278 /// Id of last collection token279 /// Collection id (controlled?1)280 ItemListIndex: map hasher(blake2_128_concat) CollectionId => TokenId;281 //#endregion282283 //#region Chain limits struct284 pub ChainLimit get(fn chain_limit) config(): ChainLimits;285 //#endregion286287 //#region Bound counters288 /// Amount of collections destroyed, used for total amount tracking with289 /// CreatedCollectionCount290 DestroyedCollectionCount: u32;291 /// Total amount of account owned tokens (NFTs + RFTs + unique fungibles)292 /// Account id (real)293 pub AccountItemCount get(fn account_item_count): map hasher(twox_64_concat) T::AccountId => u32;294 //#endregion295296 //#region Basic collections297 /// Collection info298 /// Collection id (controlled?1)299 pub CollectionById get(fn collection_id) config(): map hasher(blake2_128_concat) CollectionId => Option<Collection<T>> = None;300 /// List of collection admins301 /// Collection id (controlled?2)302 pub AdminList get(fn admin_list_collection): map hasher(blake2_128_concat) CollectionId => Vec<T::CrossAccountId>;303 /// Whitelisted collection users304 /// Collection id (controlled?2), user id (controlled?3)305 pub WhiteList get(fn white_list): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) T::AccountId => bool;306 //#endregion307308 /// How many of collection items user have309 /// Collection id (controlled?2), account id (real)310 pub Balance get(fn balance_count): double_map hasher(blake2_128_concat) CollectionId, hasher(twox_64_concat) T::AccountId => u128;311312 /// Amount of items which spender can transfer out of owners account (via transferFrom)313 /// Collection id (controlled?2), (token id (controlled ?2) + owner account id (real) + spender account id (controlled?3))314 /// TODO: Off chain worker should remove from this map when token gets removed315 pub Allowances get(fn approved): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) (TokenId, T::AccountId, T::AccountId) => u128;316317 //#region Item collections318 /// Collection id (controlled?2), token id (controlled?1)319 pub NftItemList get(fn nft_item_id) config(): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => Option<NftItemType<T::CrossAccountId>>;320 /// Collection id (controlled?2), owner (controlled?2)321 pub FungibleItemList get(fn fungible_item_id) config(): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) T::AccountId => FungibleItemType;322 /// Collection id (controlled?2), token id (controlled?1)323 pub ReFungibleItemList get(fn refungible_item_id) config(): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => Option<ReFungibleItemType<T::CrossAccountId>>;324 //#endregion325326 //#region Index list327 /// Collection id (controlled?2), tokens owner (controlled?2)328 pub AddressTokens get(fn address_tokens): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) T::AccountId => Vec<TokenId>;329 //#endregion330331 //#region Tokens transfer rate limit baskets332 /// (Collection id (controlled?2), who created (real))333 /// TODO: Off chain worker should remove from this map when collection gets removed334 pub CreateItemBasket get(fn create_item_basket): map hasher(blake2_128_concat) (CollectionId, T::AccountId) => T::BlockNumber;335 /// Collection id (controlled?2), token id (controlled?2)336 pub NftTransferBasket get(fn nft_transfer_basket): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => T::BlockNumber;337 /// Collection id (controlled?2), owning user (real)338 pub FungibleTransferBasket get(fn fungible_transfer_basket): double_map hasher(blake2_128_concat) CollectionId, hasher(twox_64_concat) T::AccountId => T::BlockNumber;339 /// Collection id (controlled?2), token id (controlled?2)340 pub ReFungibleTransferBasket get(fn refungible_transfer_basket): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => T::BlockNumber;341 //#endregion342343 /// Variable metadata sponsoring344 /// Collection id (controlled?2), token id (controlled?2)345 pub VariableMetaDataBasket get(fn variable_meta_data_basket): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => Option<T::BlockNumber> = None;346 347 //#region Contract Sponsorship and Ownership348 /// Contract address (real)349 pub ContractOwner get(fn contract_owner): map hasher(twox_64_concat) T::AccountId => Option<T::AccountId>;350 /// Contract address (real)351 pub ContractSelfSponsoring get(fn contract_self_sponsoring): map hasher(twox_64_concat) T::AccountId => bool;352 /// (Contract address(real), caller (real))353 pub ContractSponsorBasket get(fn contract_sponsor_basket): map hasher(twox_64_concat) (T::AccountId, T::AccountId) => T::BlockNumber;354 /// Contract address (real)355 pub ContractSponsoringRateLimit get(fn contract_sponsoring_rate_limit): map hasher(twox_64_concat) T::AccountId => T::BlockNumber;356 /// Contract address (real)357 pub ContractWhiteListEnabled get(fn contract_white_list_enabled): map hasher(twox_64_concat) T::AccountId => bool; 358 /// Contract address (real) => Whitelisted user (controlled?3)359 pub ContractWhiteList get(fn contract_white_list): double_map hasher(twox_64_concat) T::AccountId, hasher(blake2_128_concat) T::AccountId => bool; 360 //#endregion361 }362 add_extra_genesis {363 build(|config: &GenesisConfig<T>| {364 // Modification of storage365 for (_num, _c) in &config.collection_id {366 <Module<T>>::init_collection(_c);367 }368369 for (_num, _c, _i) in &config.nft_item_id {370 <Module<T>>::init_nft_token(*_c, _i);371 }372373 for (collection_id, account_id, fungible_item) in &config.fungible_item_id {374 <Module<T>>::init_fungible_token(*collection_id, &T::CrossAccountId::from_sub(account_id.clone()), fungible_item);375 }376377 for (_num, _c, _i) in &config.refungible_item_id {378 <Module<T>>::init_refungible_token(*_c, _i);379 }380 })381 }382}383384decl_event!(385 pub enum Event<T>386 where387 AccountId = <T as frame_system::Config>::AccountId,388 CrossAccountId = <T as Config>::CrossAccountId,389 {390 /// New collection was created391 /// 392 /// # Arguments393 /// 394 /// * collection_id: Globally unique identifier of newly created collection.395 /// 396 /// * mode: [CollectionMode] converted into u8.397 /// 398 /// * account_id: Collection owner.399 CollectionCreated(CollectionId, u8, AccountId),400401 /// New item was created.402 /// 403 /// # Arguments404 /// 405 /// * collection_id: Id of the collection where item was created.406 /// 407 /// * item_id: Id of an item. Unique within the collection.408 ///409 /// * recipient: Owner of newly created item 410 ItemCreated(CollectionId, TokenId, CrossAccountId),411412 /// Collection item was burned.413 /// 414 /// # Arguments415 /// 416 /// collection_id.417 /// 418 /// item_id: Identifier of burned NFT.419 ItemDestroyed(CollectionId, TokenId),420421 /// Item was transferred422 ///423 /// * collection_id: Id of collection to which item is belong424 ///425 /// * item_id: Id of an item426 ///427 /// * sender: Original owner of item428 ///429 /// * recipient: New owner of item430 ///431 /// * amount: Always 1 for NFT432 Transfer(CollectionId, TokenId, CrossAccountId, CrossAccountId, u128),433434 /// * collection_id435 ///436 /// * item_id437 ///438 /// * sender439 ///440 /// * spender441 ///442 /// * amount443 Approved(CollectionId, TokenId, CrossAccountId, CrossAccountId, u128),444 }445);446447decl_module! {448 pub struct Module<T: Config> for enum Call 449 where 450 origin: T::Origin451 {452 fn deposit_event() = default;453 type Error = Error<T>;454455 fn on_initialize(_now: T::BlockNumber) -> Weight {456 0457 }458459 /// This method creates a Collection of NFTs. Each Token may have multiple properties encoded as an array of bytes of certain length. The initial owner and admin of the collection are set to the address that signed the transaction. Both addresses can be changed later.460 /// 461 /// # Permissions462 /// 463 /// * Anyone.464 /// 465 /// # Arguments466 /// 467 /// * collection_name: UTF-16 string with collection name (limit 64 characters), will be stored as zero-terminated.468 /// 469 /// * collection_description: UTF-16 string with collection description (limit 256 characters), will be stored as zero-terminated.470 /// 471 /// * token_prefix: UTF-8 string with token prefix.472 /// 473 /// * mode: [CollectionMode] collection type and type dependent data.474 // returns collection ID475 #[weight = <T as Config>::WeightInfo::create_collection()]476 #[transactional]477 pub fn create_collection(origin,478 collection_name: Vec<u16>,479 collection_description: Vec<u16>,480 token_prefix: Vec<u8>,481 mode: CollectionMode) -> DispatchResult {482483 // Anyone can create a collection484 let who = ensure_signed(origin)?;485486 // Take a (non-refundable) deposit of collection creation487 let mut imbalance = <<<T as Config>::Currency as Currency<T::AccountId>>::PositiveImbalance>::zero();488 imbalance.subsume(<<T as Config>::Currency as Currency<T::AccountId>>::deposit_creating(489 &T::TreasuryAccountId::get(),490 T::CollectionCreationPrice::get(),491 ));492 <T as Config>::Currency::settle(493 &who,494 imbalance,495 WithdrawReasons::TRANSFER,496 ExistenceRequirement::KeepAlive,497 ).map_err(|_| Error::<T>::NoPermission)?;498499 let decimal_points = match mode {500 CollectionMode::Fungible(points) => points,501 _ => 0502 };503504 let chain_limit = ChainLimit::get();505506 let created_count = CreatedCollectionCount::get();507 let destroyed_count = DestroyedCollectionCount::get();508509 // bound Total number of collections510 ensure!(created_count - destroyed_count < chain_limit.collection_numbers_limit, Error::<T>::TotalCollectionsLimitExceeded);511512 // check params513 ensure!(decimal_points <= MAX_DECIMAL_POINTS, Error::<T>::CollectionDecimalPointLimitExceeded);514 ensure!(collection_name.len() <= 64, Error::<T>::CollectionNameLimitExceeded);515 ensure!(collection_description.len() <= 256, Error::<T>::CollectionDescriptionLimitExceeded);516 ensure!(token_prefix.len() <= 16, Error::<T>::CollectionTokenPrefixLimitExceeded);517518 // Generate next collection ID519 let next_id = created_count520 .checked_add(1)521 .ok_or(Error::<T>::NumOverflow)?;522523 CreatedCollectionCount::put(next_id);524525 let limits = CollectionLimits {526 sponsored_data_size: chain_limit.custom_data_limit,527 ..Default::default()528 };529530 // Create new collection531 let new_collection = Collection {532 owner: who.clone(),533 name: collection_name,534 mode: mode.clone(),535 mint_mode: false,536 access: AccessMode::Normal,537 description: collection_description,538 decimal_points: decimal_points,539 token_prefix: token_prefix,540 offchain_schema: Vec::new(),541 schema_version: SchemaVersion::ImageURL,542 sponsorship: SponsorshipState::Disabled,543 variable_on_chain_schema: Vec::new(),544 const_on_chain_schema: Vec::new(),545 limits,546 };547548 // Add new collection to map549 <CollectionById<T>>::insert(next_id, new_collection);550551 // call event552 Self::deposit_event(RawEvent::CollectionCreated(next_id, mode.into(), who));553554 Ok(())555 }556557 /// **DANGEROUS**: Destroys collection and all NFTs within this collection. Users irrecoverably lose their assets and may lose real money.558 /// 559 /// # Permissions560 /// 561 /// * Collection Owner.562 /// 563 /// # Arguments564 /// 565 /// * collection_id: collection to destroy.566 #[weight = <T as Config>::WeightInfo::destroy_collection()]567 #[transactional]568 pub fn destroy_collection(origin, collection_id: CollectionId) -> DispatchResult {569570 let sender = ensure_signed(origin)?;571 let collection = Self::get_collection(collection_id)?;572 Self::check_owner_permissions(&collection, &sender)?;573 if !collection.limits.owner_can_destroy {574 fail!(Error::<T>::NoPermission);575 }576577 <AddressTokens<T>>::remove_prefix(collection_id);578 <Allowances<T>>::remove_prefix(collection_id);579 <Balance<T>>::remove_prefix(collection_id);580 <ItemListIndex>::remove(collection_id);581 <AdminList<T>>::remove(collection_id);582 <CollectionById<T>>::remove(collection_id);583 <WhiteList<T>>::remove_prefix(collection_id);584585 <NftItemList<T>>::remove_prefix(collection_id);586 <FungibleItemList<T>>::remove_prefix(collection_id);587 <ReFungibleItemList<T>>::remove_prefix(collection_id);588589 <NftTransferBasket<T>>::remove_prefix(collection_id);590 <FungibleTransferBasket<T>>::remove_prefix(collection_id);591 <ReFungibleTransferBasket<T>>::remove_prefix(collection_id);592593 <VariableMetaDataBasket<T>>::remove_prefix(collection_id);594595 DestroyedCollectionCount::put(DestroyedCollectionCount::get()596 .checked_add(1)597 .ok_or(Error::<T>::NumOverflow)?);598599 Ok(())600 }601602 /// Add an address to white list.603 /// 604 /// # Permissions605 /// 606 /// * Collection Owner607 /// * Collection Admin608 /// 609 /// # Arguments610 /// 611 /// * collection_id.612 /// 613 /// * address.614 #[weight = <T as Config>::WeightInfo::add_to_white_list()]615 #[transactional]616 pub fn add_to_white_list(origin, collection_id: CollectionId, address: T::CrossAccountId) -> DispatchResult{617618 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);619 let collection = Self::get_collection(collection_id)?;620621 Self::toggle_white_list_internal(622 &sender,623 &collection,624 &address,625 true,626 )?;627628 Ok(())629 }630631 /// Remove an address from white list.632 /// 633 /// # Permissions634 /// 635 /// * Collection Owner636 /// * Collection Admin637 /// 638 /// # Arguments639 /// 640 /// * collection_id.641 /// 642 /// * address.643 #[weight = <T as Config>::WeightInfo::remove_from_white_list()]644 #[transactional]645 pub fn remove_from_white_list(origin, collection_id: CollectionId, address: T::CrossAccountId) -> DispatchResult{646647 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);648 let collection = Self::get_collection(collection_id)?;649650 Self::toggle_white_list_internal(651 &sender,652 &collection,653 &address,654 false,655 )?;656657 Ok(())658 }659660 /// Toggle between normal and white list access for the methods with access for `Anyone`.661 /// 662 /// # Permissions663 /// 664 /// * Collection Owner.665 /// 666 /// # Arguments667 /// 668 /// * collection_id.669 /// 670 /// * mode: [AccessMode]671 #[weight = <T as Config>::WeightInfo::set_public_access_mode()]672 #[transactional]673 pub fn set_public_access_mode(origin, collection_id: CollectionId, mode: AccessMode) -> DispatchResult674 {675 let sender = ensure_signed(origin)?;676677 let mut target_collection = Self::get_collection(collection_id)?;678 Self::check_owner_permissions(&target_collection, &sender)?;679 target_collection.access = mode;680 Self::save_collection(target_collection);681682 Ok(())683 }684685 /// Allows Anyone to create tokens if:686 /// * White List is enabled, and687 /// * Address is added to white list, and688 /// * This method was called with True parameter689 /// 690 /// # Permissions691 /// * Collection Owner692 ///693 /// # Arguments694 /// 695 /// * collection_id.696 /// 697 /// * mint_permission: Boolean parameter. If True, allows minting to Anyone with conditions above.698 #[weight = <T as Config>::WeightInfo::set_mint_permission()]699 #[transactional]700 pub fn set_mint_permission(origin, collection_id: CollectionId, mint_permission: bool) -> DispatchResult701 {702 let sender = ensure_signed(origin)?;703704 let mut target_collection = Self::get_collection(collection_id)?;705 Self::check_owner_permissions(&target_collection, &sender)?;706 target_collection.mint_mode = mint_permission;707 Self::save_collection(target_collection);708709 Ok(())710 }711712 /// Change the owner of the collection.713 /// 714 /// # Permissions715 /// 716 /// * Collection Owner.717 /// 718 /// # Arguments719 /// 720 /// * collection_id.721 /// 722 /// * new_owner.723 #[weight = <T as Config>::WeightInfo::change_collection_owner()]724 #[transactional]725 pub fn change_collection_owner(origin, collection_id: CollectionId, new_owner: T::AccountId) -> DispatchResult {726727 let sender = ensure_signed(origin)?;728 let mut target_collection = Self::get_collection(collection_id)?;729 Self::check_owner_permissions(&target_collection, &sender)?;730 target_collection.owner = new_owner;731 Self::save_collection(target_collection);732733 Ok(())734 }735736 /// Adds an admin of the Collection.737 /// NFT Collection can be controlled by multiple admin addresses (some which can also be servers, for example). Admins can issue and burn NFTs, as well as add and remove other admins, but cannot change NFT or Collection ownership. 738 /// 739 /// # Permissions740 /// 741 /// * Collection Owner.742 /// * Collection Admin.743 /// 744 /// # Arguments745 /// 746 /// * collection_id: ID of the Collection to add admin for.747 /// 748 /// * new_admin_id: Address of new admin to add.749 #[weight = <T as Config>::WeightInfo::add_collection_admin()]750 #[transactional]751 pub fn add_collection_admin(origin, collection_id: CollectionId, new_admin_id: T::CrossAccountId) -> DispatchResult {752 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);753 let collection = Self::get_collection(collection_id)?;754 Self::check_owner_or_admin_permissions(&collection, &sender)?;755 let mut admin_arr = <AdminList<T>>::get(collection_id);756757 match admin_arr.binary_search(&new_admin_id) {758 Ok(_) => {},759 Err(idx) => {760 let limits = ChainLimit::get();761 ensure!(admin_arr.len() < limits.collections_admins_limit as usize, Error::<T>::CollectionAdminsLimitExceeded);762 admin_arr.insert(idx, new_admin_id);763 <AdminList<T>>::insert(collection_id, admin_arr);764 }765 }766 Ok(())767 }768769 /// Remove admin address of the Collection. An admin address can remove itself. List of admins may become empty, in which case only Collection Owner will be able to add an Admin.770 ///771 /// # Permissions772 /// 773 /// * Collection Owner.774 /// * Collection Admin.775 /// 776 /// # Arguments777 /// 778 /// * collection_id: ID of the Collection to remove admin for.779 /// 780 /// * account_id: Address of admin to remove.781 #[weight = <T as Config>::WeightInfo::remove_collection_admin()]782 #[transactional]783 pub fn remove_collection_admin(origin, collection_id: CollectionId, account_id: T::CrossAccountId) -> DispatchResult {784 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);785 let collection = Self::get_collection(collection_id)?;786 Self::check_owner_or_admin_permissions(&collection, &sender)?;787 let mut admin_arr = <AdminList<T>>::get(collection_id);788789 match admin_arr.binary_search(&account_id) {790 Ok(idx) => {791 admin_arr.remove(idx);792 <AdminList<T>>::insert(collection_id, admin_arr);793 },794 Err(_) => {}795 }796 Ok(())797 }798799 /// # Permissions800 /// 801 /// * Collection Owner802 /// 803 /// # Arguments804 /// 805 /// * collection_id.806 /// 807 /// * new_sponsor.808 #[weight = <T as Config>::WeightInfo::set_collection_sponsor()]809 #[transactional]810 pub fn set_collection_sponsor(origin, collection_id: CollectionId, new_sponsor: T::AccountId) -> DispatchResult {811 let sender = ensure_signed(origin)?;812 let mut target_collection = Self::get_collection(collection_id)?;813 Self::check_owner_permissions(&target_collection, &sender)?;814815 target_collection.sponsorship = SponsorshipState::Unconfirmed(new_sponsor);816 Self::save_collection(target_collection);817818 Ok(())819 }820821 /// # Permissions822 /// 823 /// * Sponsor.824 /// 825 /// # Arguments826 /// 827 /// * collection_id.828 #[weight = <T as Config>::WeightInfo::confirm_sponsorship()]829 #[transactional]830 pub fn confirm_sponsorship(origin, collection_id: CollectionId) -> DispatchResult {831 let sender = ensure_signed(origin)?;832833 let mut target_collection = Self::get_collection(collection_id)?;834 ensure!(835 target_collection.sponsorship.pending_sponsor() == Some(&sender),836 Error::<T>::ConfirmUnsetSponsorFail837 );838839 target_collection.sponsorship = SponsorshipState::Confirmed(sender);840 Self::save_collection(target_collection);841842 Ok(())843 }844845 /// Switch back to pay-per-own-transaction model.846 ///847 /// # Permissions848 ///849 /// * Collection owner.850 /// 851 /// # Arguments852 /// 853 /// * collection_id.854 #[weight = <T as Config>::WeightInfo::remove_collection_sponsor()]855 #[transactional]856 pub fn remove_collection_sponsor(origin, collection_id: CollectionId) -> DispatchResult {857 let sender = ensure_signed(origin)?;858859 let mut target_collection = Self::get_collection(collection_id)?;860 Self::check_owner_permissions(&target_collection, &sender)?;861862 target_collection.sponsorship = SponsorshipState::Disabled;863 Self::save_collection(target_collection);864865 Ok(())866 }867868 /// This method creates a concrete instance of NFT Collection created with CreateCollection method.869 /// 870 /// # Permissions871 /// 872 /// * Collection Owner.873 /// * Collection Admin.874 /// * Anyone if875 /// * White List is enabled, and876 /// * Address is added to white list, and877 /// * MintPermission is enabled (see SetMintPermission method)878 /// 879 /// # Arguments880 /// 881 /// * collection_id: ID of the collection.882 /// 883 /// * owner: Address, initial owner of the NFT.884 ///885 /// * data: Token data to store on chain.886 // #[weight =887 // (130_000_000 as Weight)888 // .saturating_add((2135 as Weight).saturating_mul((properties.len() as u64) as Weight))889 // .saturating_add(RocksDbWeight::get().reads(10 as Weight))890 // .saturating_add(RocksDbWeight::get().writes(8 as Weight))]891892 #[weight = <T as Config>::WeightInfo::create_item(data.len())]893 #[transactional]894 pub fn create_item(origin, collection_id: CollectionId, owner: T::CrossAccountId, data: CreateItemData) -> DispatchResult {895 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);896 let collection = Self::get_collection(collection_id)?;897898 Self::create_item_internal(&sender, &collection, &owner, data)?;899900 Self::submit_logs(collection)?;901 Ok(())902 }903904 /// This method creates multiple items in a collection created with CreateCollection method.905 /// 906 /// # Permissions907 /// 908 /// * Collection Owner.909 /// * Collection Admin.910 /// * Anyone if911 /// * White List is enabled, and912 /// * Address is added to white list, and913 /// * MintPermission is enabled (see SetMintPermission method)914 /// 915 /// # Arguments916 /// 917 /// * collection_id: ID of the collection.918 /// 919 /// * itemsData: Array items properties. Each property is an array of bytes itself, see [create_item].920 /// 921 /// * owner: Address, initial owner of the NFT.922 #[weight = <T as Config>::WeightInfo::create_item(items_data.into_iter()923 .map(|data| { data.len() })924 .sum())]925 #[transactional]926 pub fn create_multiple_items(origin, collection_id: CollectionId, owner: T::CrossAccountId, items_data: Vec<CreateItemData>) -> DispatchResult {927928 ensure!(items_data.len() > 0, Error::<T>::EmptyArgument);929 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);930 let collection = Self::get_collection(collection_id)?;931932 Self::create_multiple_items_internal(&sender, &collection, &owner, items_data)?;933934 Self::submit_logs(collection)?;935 Ok(())936 }937938 /// Destroys a concrete instance of NFT.939 /// 940 /// # Permissions941 /// 942 /// * Collection Owner.943 /// * Collection Admin.944 /// * Current NFT Owner.945 /// 946 /// # Arguments947 /// 948 /// * collection_id: ID of the collection.949 /// 950 /// * item_id: ID of NFT to burn.951 #[weight = <T as Config>::WeightInfo::burn_item()]952 #[transactional]953 pub fn burn_item(origin, collection_id: CollectionId, item_id: TokenId, value: u128) -> DispatchResult {954955 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);956 let target_collection = Self::get_collection(collection_id)?;957958 Self::burn_item_internal(&sender, &target_collection, item_id, value)?;959960 Self::submit_logs(target_collection)?;961 Ok(())962 }963964 /// Change ownership of the token.965 /// 966 /// # Permissions967 /// 968 /// * Collection Owner969 /// * Collection Admin970 /// * Current NFT owner971 ///972 /// # Arguments973 /// 974 /// * recipient: Address of token recipient.975 /// 976 /// * collection_id.977 /// 978 /// * item_id: ID of the item979 /// * Non-Fungible Mode: Required.980 /// * Fungible Mode: Ignored.981 /// * Re-Fungible Mode: Required.982 /// 983 /// * value: Amount to transfer.984 /// * Non-Fungible Mode: Ignored985 /// * Fungible Mode: Must specify transferred amount986 /// * Re-Fungible Mode: Must specify transferred portion (between 0 and 1)987 #[weight = <T as Config>::WeightInfo::transfer()]988 #[transactional]989 pub fn transfer(origin, recipient: T::CrossAccountId, collection_id: CollectionId, item_id: TokenId, value: u128) -> DispatchResult {990 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);991 let collection = Self::get_collection(collection_id)?;992993 Self::transfer_internal(&sender, &recipient, &collection, item_id, value)?;994995 Self::submit_logs(collection)?;996 Ok(())997 }998999 /// Set, change, or remove approved address to transfer the ownership of the NFT.1000 /// 1001 /// # Permissions1002 /// 1003 /// * Collection Owner1004 /// * Collection Admin1005 /// * Current NFT owner1006 /// 1007 /// # Arguments1008 /// 1009 /// * approved: Address that is approved to transfer this NFT or zero (if needed to remove approval).1010 /// 1011 /// * collection_id.1012 /// 1013 /// * item_id: ID of the item.1014 #[weight = <T as Config>::WeightInfo::approve()]1015 #[transactional]1016 pub fn approve(origin, spender: T::CrossAccountId, collection_id: CollectionId, item_id: TokenId, amount: u128) -> DispatchResult {1017 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1018 let collection = Self::get_collection(collection_id)?;10191020 Self::approve_internal(&sender, &spender, &collection, item_id, amount)?;10211022 Self::submit_logs(collection)?;1023 Ok(())1024 }1025 1026 /// Change ownership of a NFT on behalf of the owner. See Approve method for additional information. After this method executes, the approval is removed so that the approved address will not be able to transfer this NFT again from this owner.1027 /// 1028 /// # Permissions1029 /// * Collection Owner1030 /// * Collection Admin1031 /// * Current NFT owner1032 /// * Address approved by current NFT owner1033 /// 1034 /// # Arguments1035 /// 1036 /// * from: Address that owns token.1037 /// 1038 /// * recipient: Address of token recipient.1039 /// 1040 /// * collection_id.1041 /// 1042 /// * item_id: ID of the item.1043 /// 1044 /// * value: Amount to transfer.1045 #[weight = <T as Config>::WeightInfo::transfer_from()]1046 #[transactional]1047 pub fn transfer_from(origin, from: T::CrossAccountId, recipient: T::CrossAccountId, collection_id: CollectionId, item_id: TokenId, value: u128 ) -> DispatchResult {1048 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1049 let collection = Self::get_collection(collection_id)?;10501051 Self::transfer_from_internal(&sender, &from, &recipient, &collection, item_id, value)?;10521053 Self::submit_logs(collection)?;1054 Ok(())1055 }1056 // #[weight = 0]1057 // // let no_perm_mes = "You do not have permissions to modify this collection";1058 // // ensure!(<ApprovedList<T>>::contains_key((collection_id, item_id)), no_perm_mes);1059 // // let list_itm = <ApprovedList<T>>::get((collection_id, item_id));1060 // // ensure!(list_itm.contains(&new_owner.clone()), no_perm_mes);10611062 // // // on_nft_received call10631064 // // Self::transfer(origin, collection_id, item_id, new_owner)?;10651066 // Ok(())1067 // }10681069 /// Set off-chain data schema.1070 /// 1071 /// # Permissions1072 /// 1073 /// * Collection Owner1074 /// * Collection Admin1075 /// 1076 /// # Arguments1077 /// 1078 /// * collection_id.1079 /// 1080 /// * schema: String representing the offchain data schema.1081 #[weight = <T as Config>::WeightInfo::set_variable_meta_data()]1082 #[transactional]1083 pub fn set_variable_meta_data (1084 origin,1085 collection_id: CollectionId,1086 item_id: TokenId,1087 data: Vec<u8>1088 ) -> DispatchResult {1089 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1090 1091 let collection = Self::get_collection(collection_id)?;10921093 Self::set_variable_meta_data_internal(&sender, &collection, item_id, data)?;10941095 Ok(())1096 }1097 1098 /// Set schema standard1099 /// ImageURL1100 /// Unique1101 /// 1102 /// # Permissions1103 /// 1104 /// * Collection Owner1105 /// * Collection Admin1106 /// 1107 /// # Arguments1108 /// 1109 /// * collection_id.1110 /// 1111 /// * schema: SchemaVersion: enum1112 #[weight = <T as Config>::WeightInfo::set_schema_version()]1113 #[transactional]1114 pub fn set_schema_version(1115 origin,1116 collection_id: CollectionId,1117 version: SchemaVersion1118 ) -> DispatchResult {1119 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1120 let mut target_collection = Self::get_collection(collection_id)?;1121 Self::check_owner_or_admin_permissions(&target_collection, &sender)?;1122 target_collection.schema_version = version;1123 Self::save_collection(target_collection);11241125 Ok(())1126 }11271128 /// Set off-chain data schema.1129 /// 1130 /// # Permissions1131 /// 1132 /// * Collection Owner1133 /// * Collection Admin1134 /// 1135 /// # Arguments1136 /// 1137 /// * collection_id.1138 /// 1139 /// * schema: String representing the offchain data schema.1140 #[weight = <T as Config>::WeightInfo::set_offchain_schema()]1141 #[transactional]1142 pub fn set_offchain_schema(1143 origin,1144 collection_id: CollectionId,1145 schema: Vec<u8>1146 ) -> DispatchResult {1147 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1148 let mut target_collection = Self::get_collection(collection_id)?;1149 Self::check_owner_or_admin_permissions(&target_collection, &sender)?;11501151 // check schema limit1152 ensure!(schema.len() as u32 <= ChainLimit::get().offchain_schema_limit, "");11531154 target_collection.offchain_schema = schema;1155 Self::save_collection(target_collection);11561157 Ok(())1158 }11591160 /// Set const on-chain data schema.1161 /// 1162 /// # Permissions1163 /// 1164 /// * Collection Owner1165 /// * Collection Admin1166 /// 1167 /// # Arguments1168 /// 1169 /// * collection_id.1170 /// 1171 /// * schema: String representing the const on-chain data schema.1172 #[weight = <T as Config>::WeightInfo::set_const_on_chain_schema()]1173 #[transactional]1174 pub fn set_const_on_chain_schema (1175 origin,1176 collection_id: CollectionId,1177 schema: Vec<u8>1178 ) -> DispatchResult {1179 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1180 let mut target_collection = Self::get_collection(collection_id)?;1181 Self::check_owner_or_admin_permissions(&target_collection, &sender)?;11821183 // check schema limit1184 ensure!(schema.len() as u32 <= ChainLimit::get().const_on_chain_schema_limit, "");11851186 target_collection.const_on_chain_schema = schema;1187 Self::save_collection(target_collection);11881189 Ok(())1190 }11911192 /// Set variable on-chain data schema.1193 /// 1194 /// # Permissions1195 /// 1196 /// * Collection Owner1197 /// * Collection Admin1198 /// 1199 /// # Arguments1200 /// 1201 /// * collection_id.1202 /// 1203 /// * schema: String representing the variable on-chain data schema.1204 #[weight = <T as Config>::WeightInfo::set_const_on_chain_schema()]1205 #[transactional]1206 pub fn set_variable_on_chain_schema (1207 origin,1208 collection_id: CollectionId,1209 schema: Vec<u8>1210 ) -> DispatchResult {1211 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1212 let mut target_collection = Self::get_collection(collection_id)?;1213 Self::check_owner_or_admin_permissions(&target_collection, &sender)?;12141215 // check schema limit1216 ensure!(schema.len() as u32 <= ChainLimit::get().variable_on_chain_schema_limit, "");12171218 target_collection.variable_on_chain_schema = schema;1219 Self::save_collection(target_collection);12201221 Ok(())1222 }12231224 // Sudo permissions function1225 #[weight = <T as Config>::WeightInfo::set_chain_limits()]1226 #[transactional]1227 pub fn set_chain_limits(1228 origin,1229 limits: ChainLimits1230 ) -> DispatchResult {12311232 #[cfg(not(feature = "runtime-benchmarks"))]1233 ensure_root(origin)?;12341235 <ChainLimit>::put(limits);1236 Ok(())1237 }12381239 /// Enable smart contract self-sponsoring.1240 /// 1241 /// # Permissions1242 /// 1243 /// * Contract Owner1244 /// 1245 /// # Arguments1246 /// 1247 /// * contract address1248 /// * enable flag1249 /// 1250 #[weight = <T as Config>::WeightInfo::enable_contract_sponsoring()]1251 #[transactional]1252 pub fn enable_contract_sponsoring(1253 origin,1254 contract_address: T::AccountId,1255 enable: bool1256 ) -> DispatchResult {12571258 let sender = ensure_signed(origin)?;12591260 #[cfg(feature = "runtime-benchmarks")]1261 <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());12621263 Self::ensure_contract_owned(sender, &contract_address)?;12641265 <ContractSelfSponsoring<T>>::insert(contract_address, enable);1266 Ok(())1267 }12681269 /// Set the rate limit for contract sponsoring to specified number of blocks.1270 /// 1271 /// If not set (has the default value of 0 blocks), the sponsoring will be disabled. 1272 /// If set to the number B (for blocks), the transactions will be sponsored with a rate 1273 /// limit of B, i.e. fees for every transaction sent to this smart contract will be paid 1274 /// from contract endowment if there are at least B blocks between such transactions. 1275 /// Nonetheless, if transactions are sent more frequently, the fees are paid by the sender.1276 /// 1277 /// # Permissions1278 /// 1279 /// * Contract Owner1280 /// 1281 /// # Arguments1282 /// 1283 /// -`contract_address`: Address of the contract to sponsor1284 /// -`rate_limit`: Number of blocks to wait until the next sponsored transaction is allowed1285 /// 1286 #[weight = <T as Config>::WeightInfo::set_contract_sponsoring_rate_limit()]1287 #[transactional]1288 pub fn set_contract_sponsoring_rate_limit(1289 origin,1290 contract_address: T::AccountId,1291 rate_limit: T::BlockNumber1292 ) -> DispatchResult {1293 let sender = ensure_signed(origin)?;12941295 #[cfg(feature = "runtime-benchmarks")]1296 <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());12971298 Self::ensure_contract_owned(sender, &contract_address)?;1299 <ContractSponsoringRateLimit<T>>::insert(contract_address, rate_limit);1300 Ok(())1301 }13021303 /// Enable the white list for a contract. Only addresses added to the white list with addToContractWhiteList will be able to call this smart contract.1304 /// 1305 /// # Permissions1306 /// 1307 /// * Address that deployed smart contract.1308 /// 1309 /// # Arguments1310 /// 1311 /// -`contract_address`: Address of the contract.1312 /// 1313 /// - `enable`: . 1314 #[weight = <T as Config>::WeightInfo::toggle_contract_white_list()]1315 #[transactional]1316 pub fn toggle_contract_white_list(1317 origin,1318 contract_address: T::AccountId,1319 enable: bool1320 ) -> DispatchResult {1321 let sender = ensure_signed(origin)?;13221323 #[cfg(feature = "runtime-benchmarks")]1324 <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());13251326 Self::ensure_contract_owned(sender, &contract_address)?;1327 if enable {1328 <ContractWhiteListEnabled<T>>::insert(contract_address, true);1329 } else {1330 <ContractWhiteListEnabled<T>>::remove(contract_address);1331 }1332 Ok(())1333 }1334 1335 /// Add an address to smart contract white list.1336 /// 1337 /// # Permissions1338 /// 1339 /// * Address that deployed smart contract.1340 /// 1341 /// # Arguments1342 /// 1343 /// -`contract_address`: Address of the contract.1344 ///1345 /// -`account_address`: Address to add.1346 #[weight = <T as Config>::WeightInfo::add_to_contract_white_list()]1347 #[transactional]1348 pub fn add_to_contract_white_list(1349 origin,1350 contract_address: T::AccountId,1351 account_address: T::AccountId1352 ) -> DispatchResult {1353 let sender = ensure_signed(origin)?;13541355 #[cfg(feature = "runtime-benchmarks")]1356 <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());1357 1358 Self::ensure_contract_owned(sender, &contract_address)?; 1359 <ContractWhiteList<T>>::insert(contract_address, account_address, true);1360 Ok(())1361 }13621363 /// Remove an address from smart contract white list.1364 /// 1365 /// # Permissions1366 /// 1367 /// * Address that deployed smart contract.1368 /// 1369 /// # Arguments1370 /// 1371 /// -`contract_address`: Address of the contract.1372 ///1373 /// -`account_address`: Address to remove.1374 #[weight = <T as Config>::WeightInfo::remove_from_contract_white_list()]1375 #[transactional]1376 pub fn remove_from_contract_white_list(1377 origin,1378 contract_address: T::AccountId,1379 account_address: T::AccountId1380 ) -> DispatchResult {1381 let sender = ensure_signed(origin)?;13821383 #[cfg(feature = "runtime-benchmarks")]1384 <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());13851386 Self::ensure_contract_owned(sender, &contract_address)?;1387 <ContractWhiteList<T>>::remove(contract_address, account_address);1388 Ok(())1389 }13901391 #[weight = <T as Config>::WeightInfo::set_collection_limits()]1392 #[transactional]1393 pub fn set_collection_limits(1394 origin,1395 collection_id: u32,1396 new_limits: CollectionLimits<T::BlockNumber>,1397 ) -> DispatchResult {1398 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1399 let mut target_collection = Self::get_collection(collection_id)?;1400 Self::check_owner_permissions(&target_collection, &sender.as_sub())?;1401 let old_limits = &target_collection.limits;1402 let chain_limits = ChainLimit::get();14031404 // collection bounds1405 ensure!(new_limits.sponsor_transfer_timeout <= MAX_SPONSOR_TIMEOUT &&1406 new_limits.account_token_ownership_limit <= MAX_TOKEN_OWNERSHIP && 1407 new_limits.sponsored_data_size <= chain_limits.custom_data_limit,1408 Error::<T>::CollectionLimitBoundsExceeded);14091410 // token_limit check prev1411 ensure!(old_limits.token_limit >= new_limits.token_limit, Error::<T>::CollectionTokenLimitExceeded);1412 ensure!(new_limits.token_limit > 0, Error::<T>::CollectionTokenLimitExceeded);14131414 ensure!(1415 (old_limits.owner_can_transfer || !new_limits.owner_can_transfer) &&1416 (old_limits.owner_can_destroy || !new_limits.owner_can_destroy),1417 Error::<T>::OwnerPermissionsCantBeReverted,1418 );14191420 target_collection.limits = new_limits;1421 Self::save_collection(target_collection);14221423 Ok(())1424 } 1425 }1426}14271428impl<T: Config> Module<T> {1429 pub fn create_item_internal(sender: &T::CrossAccountId, collection: &CollectionHandle<T>, owner: &T::CrossAccountId, data: CreateItemData) -> DispatchResult {1430 Self::can_create_items_in_collection(&collection, &sender, &owner, 1)?;1431 Self::validate_create_item_args(&collection, &data)?;1432 Self::create_item_no_validation(&collection, owner, data)?;14331434 Ok(())1435 }14361437 pub fn transfer_internal(sender: &T::CrossAccountId, recipient: &T::CrossAccountId, target_collection: &CollectionHandle<T>, item_id: TokenId, value: u128) -> DispatchResult {1438 target_collection.consume_gas(2000000)?;1439 // Limits check1440 Self::is_correct_transfer(target_collection, &recipient)?;14411442 // Transfer permissions check1443 ensure!(Self::is_item_owner(&sender, target_collection, item_id) ||1444 Self::is_owner_or_admin_permissions(target_collection, &sender),1445 Error::<T>::NoPermission);14461447 if target_collection.access == AccessMode::WhiteList {1448 Self::check_white_list(target_collection, &sender)?;1449 Self::check_white_list(target_collection, &recipient)?;1450 }14511452 match target_collection.mode1453 {1454 CollectionMode::NFT => Self::transfer_nft(target_collection, item_id, sender.clone(), recipient.clone())?,1455 CollectionMode::Fungible(_) => Self::transfer_fungible(target_collection, value, &sender, &recipient)?,1456 CollectionMode::ReFungible => Self::transfer_refungible(target_collection, item_id, value, sender.clone(), recipient.clone())?,1457 _ => ()1458 };14591460 Self::deposit_event(RawEvent::Transfer(target_collection.id, item_id, sender.clone(), recipient.clone(), value));14611462 Ok(())1463 }14641465 pub fn approve_internal(1466 sender: &T::CrossAccountId,1467 spender: &T::CrossAccountId,1468 collection: &CollectionHandle<T>,1469 item_id: TokenId,1470 amount: u1281471 ) -> DispatchResult {1472 collection.consume_gas(2000000)?;1473 Self::token_exists(&collection, item_id)?;14741475 // Transfer permissions check1476 let bypasses_limits = collection.limits.owner_can_transfer &&1477 Self::is_owner_or_admin_permissions(1478 &collection,1479 &sender,1480 );14811482 let allowance_limit = if bypasses_limits {1483 None1484 } else if let Some(amount) = Self::owned_amount(1485 &sender,1486 &collection,1487 item_id,1488 ) {1489 Some(amount)1490 } else {1491 fail!(Error::<T>::NoPermission);1492 };14931494 if collection.access == AccessMode::WhiteList {1495 Self::check_white_list(&collection, &sender)?;1496 Self::check_white_list(&collection, &spender)?;1497 }14981499 let allowance: u128 = amount1500 .checked_add(<Allowances<T>>::get(collection.id, (item_id, sender.as_sub(), spender.as_sub())))1501 .ok_or(Error::<T>::NumOverflow)?;1502 if let Some(limit) = allowance_limit {1503 ensure!(limit >= allowance, Error::<T>::TokenValueTooLow);1504 }1505 <Allowances<T>>::insert(collection.id, (item_id, sender.as_sub(), spender.as_sub()), allowance);15061507 if matches!(collection.mode, CollectionMode::NFT) {1508 // TODO: NFT: only one owner may exist for token in ERC7211509 collection.log(ERC721Events::Approval {1510 owner: *sender.as_eth(),1511 approved: *spender.as_eth(),1512 token_id: item_id.into(),1513 });1514 }15151516 if matches!(collection.mode, CollectionMode::Fungible(_)) {1517 // TODO: NFT: only one owner may exist for token in ERC201518 collection.log(ERC20Events::Approval {1519 owner: *sender.as_eth(),1520 spender: *spender.as_eth(),1521 value: allowance.into()1522 });1523 }15241525 Self::deposit_event(RawEvent::Approved(collection.id, item_id, sender.clone(), spender.clone(), allowance));1526 Ok(())1527 }15281529 pub fn transfer_from_internal(1530 sender: &T::CrossAccountId,1531 from: &T::CrossAccountId,1532 recipient: &T::CrossAccountId,1533 collection: &CollectionHandle<T>,1534 item_id: TokenId,1535 amount: u128,1536 ) -> DispatchResult {1537 collection.consume_gas(2000000)?;1538 // Check approval1539 let approval: u128 = <Allowances<T>>::get(collection.id, (item_id, from.as_sub(), sender.as_sub()));15401541 // Limits check1542 Self::is_correct_transfer(&collection, &recipient)?;15431544 // Transfer permissions check1545 ensure!(1546 approval >= amount || 1547 (1548 collection.limits.owner_can_transfer &&1549 Self::is_owner_or_admin_permissions(&collection, &sender)1550 ),1551 Error::<T>::NoPermission1552 );15531554 if collection.access == AccessMode::WhiteList {1555 Self::check_white_list(&collection, &sender)?;1556 Self::check_white_list(&collection, &recipient)?;1557 }15581559 // Reduce approval by transferred amount or remove if remaining approval drops to 01560 let allowance = approval.saturating_sub(amount);1561 if allowance > 0 {1562 <Allowances<T>>::insert(collection.id, (item_id, from.as_sub(), sender.as_sub()), allowance);1563 } else {1564 <Allowances<T>>::remove(collection.id, (item_id, from.as_sub(), sender.as_sub()));1565 }15661567 match collection.mode {1568 CollectionMode::NFT => {1569 Self::transfer_nft(&collection, item_id, from.clone(), recipient.clone())?1570 }1571 CollectionMode::Fungible(_) => {1572 Self::transfer_fungible(&collection, amount, &from, &recipient)?1573 }1574 CollectionMode::ReFungible => {1575 Self::transfer_refungible(&collection, item_id, amount, from.clone(), recipient.clone())?1576 }1577 _ => ()1578 };15791580 if matches!(collection.mode, CollectionMode::Fungible(_)) {1581 collection.log(ERC20Events::Approval {1582 owner: *from.as_eth(),1583 spender: *sender.as_eth(),1584 value: allowance.into()1585 });1586 }15871588 Ok(())1589 }15901591 pub fn set_variable_meta_data_internal(1592 sender: &T::CrossAccountId,1593 collection: &CollectionHandle<T>, 1594 item_id: TokenId,1595 data: Vec<u8>,1596 ) -> DispatchResult {1597 Self::token_exists(&collection, item_id)?;15981599 ensure!(ChainLimit::get().custom_data_limit >= data.len() as u32, Error::<T>::TokenVariableDataLimitExceeded);16001601 // Modify permissions check1602 ensure!(Self::is_item_owner(&sender, &collection, item_id) ||1603 Self::is_owner_or_admin_permissions(&collection, &sender),1604 Error::<T>::NoPermission);16051606 match collection.mode1607 {1608 CollectionMode::NFT => Self::set_nft_variable_data(&collection, item_id, data)?,1609 CollectionMode::ReFungible => Self::set_re_fungible_variable_data(&collection, item_id, data)?,1610 CollectionMode::Fungible(_) => fail!(Error::<T>::CantStoreMetadataInFungibleTokens),1611 _ => fail!(Error::<T>::UnexpectedCollectionType)1612 };16131614 Ok(())1615 }16161617 pub fn create_multiple_items_internal(1618 sender: &T::CrossAccountId,1619 collection: &CollectionHandle<T>,1620 owner: &T::CrossAccountId,1621 items_data: Vec<CreateItemData>,1622 ) -> DispatchResult {1623 Self::can_create_items_in_collection(&collection, &sender, &owner, items_data.len() as u32)?;16241625 for data in &items_data {1626 Self::validate_create_item_args(&collection, data)?;1627 }1628 for data in &items_data {1629 Self::create_item_no_validation(&collection, owner, data.clone())?;1630 }16311632 Ok(())1633 }16341635 pub fn burn_item_internal(1636 sender: &T::CrossAccountId,1637 collection: &CollectionHandle<T>,1638 item_id: TokenId,1639 value: u128,1640 ) -> DispatchResult {1641 ensure!(1642 Self::is_item_owner(&sender, &collection, item_id) ||1643 (1644 collection.limits.owner_can_transfer &&1645 Self::is_owner_or_admin_permissions(&collection, &sender)1646 ),1647 Error::<T>::NoPermission1648 );16491650 if collection.access == AccessMode::WhiteList {1651 Self::check_white_list(&collection, &sender)?;1652 }16531654 match collection.mode1655 {1656 CollectionMode::NFT => Self::burn_nft_item(&collection, item_id)?,1657 CollectionMode::Fungible(_) => Self::burn_fungible_item(&sender, &collection, value)?,1658 CollectionMode::ReFungible => Self::burn_refungible_item(&collection, item_id, &sender)?,1659 _ => ()1660 };16611662 Ok(())1663 }16641665 pub fn toggle_white_list_internal(1666 sender: &T::CrossAccountId,1667 collection: &CollectionHandle<T>,1668 address: &T::CrossAccountId,1669 whitelisted: bool,1670 ) -> DispatchResult {1671 Self::check_owner_or_admin_permissions(&collection, &sender)?;16721673 if whitelisted {1674 <WhiteList<T>>::insert(collection.id, address.as_sub(), true);1675 } else {1676 <WhiteList<T>>::remove(collection.id, address.as_sub());1677 }16781679 Ok(())1680 }16811682 fn is_correct_transfer(collection: &CollectionHandle<T>, recipient: &T::CrossAccountId) -> DispatchResult {1683 let collection_id = collection.id;16841685 // check token limit and account token limit1686 let account_items: u32 = <AddressTokens<T>>::get(collection_id, recipient.as_sub()).len() as u32;1687 ensure!(collection.limits.account_token_ownership_limit > account_items, Error::<T>::AccountTokenLimitExceeded);1688 1689 Ok(())1690 }16911692 fn can_create_items_in_collection(collection: &CollectionHandle<T>, sender: &T::CrossAccountId, owner: &T::CrossAccountId, amount: u32) -> DispatchResult {1693 let collection_id = collection.id;16941695 // check token limit and account token limit1696 let total_items: u32 = ItemListIndex::get(collection_id)1697 .checked_add(amount)1698 .ok_or(Error::<T>::CollectionTokenLimitExceeded)?;1699 let account_items: u32 = (<AddressTokens<T>>::get(collection_id, owner.as_sub()).len() as u32)1700 .checked_add(amount)1701 .ok_or(Error::<T>::AccountTokenLimitExceeded)?;1702 ensure!(collection.limits.token_limit >= total_items, Error::<T>::CollectionTokenLimitExceeded);1703 ensure!(collection.limits.account_token_ownership_limit >= account_items, Error::<T>::AccountTokenLimitExceeded);17041705 if !Self::is_owner_or_admin_permissions(collection, &sender) {1706 ensure!(collection.mint_mode == true, Error::<T>::PublicMintingNotAllowed);1707 Self::check_white_list(collection, owner)?;1708 Self::check_white_list(collection, sender)?;1709 }17101711 Ok(())1712 }17131714 fn validate_create_item_args(target_collection: &CollectionHandle<T>, data: &CreateItemData) -> DispatchResult {1715 match target_collection.mode1716 {1717 CollectionMode::NFT => {1718 if let CreateItemData::NFT(data) = data {1719 // check sizes1720 ensure!(ChainLimit::get().custom_data_limit >= data.const_data.len() as u32, Error::<T>::TokenConstDataLimitExceeded);1721 ensure!(ChainLimit::get().custom_data_limit >= data.variable_data.len() as u32, Error::<T>::TokenVariableDataLimitExceeded);1722 } else {1723 fail!(Error::<T>::NotNftDataUsedToMintNftCollectionToken);1724 }1725 },1726 CollectionMode::Fungible(_) => {1727 if let CreateItemData::Fungible(_) = data {1728 } else {1729 fail!(Error::<T>::NotFungibleDataUsedToMintFungibleCollectionToken);1730 }1731 },1732 CollectionMode::ReFungible => {1733 if let CreateItemData::ReFungible(data) = data {17341735 // check sizes1736 ensure!(ChainLimit::get().custom_data_limit >= data.const_data.len() as u32, Error::<T>::TokenConstDataLimitExceeded);1737 ensure!(ChainLimit::get().custom_data_limit >= data.variable_data.len() as u32, Error::<T>::TokenVariableDataLimitExceeded);17381739 // Check refungibility limits1740 ensure!(data.pieces <= MAX_REFUNGIBLE_PIECES, Error::<T>::WrongRefungiblePieces);1741 ensure!(data.pieces > 0, Error::<T>::WrongRefungiblePieces);1742 } else {1743 fail!(Error::<T>::NotReFungibleDataUsedToMintReFungibleCollectionToken);1744 }1745 },1746 _ => { fail!(Error::<T>::UnexpectedCollectionType); }1747 };17481749 Ok(())1750 }17511752 fn create_item_no_validation(collection: &CollectionHandle<T>, owner: &T::CrossAccountId, data: CreateItemData) -> DispatchResult {1753 match data1754 {1755 CreateItemData::NFT(data) => {1756 let item = NftItemType {1757 owner: owner.clone(),1758 const_data: data.const_data,1759 variable_data: data.variable_data1760 };17611762 Self::add_nft_item(collection, item)?;1763 },1764 CreateItemData::Fungible(data) => {1765 Self::add_fungible_item(collection, &owner, data.value)?;1766 },1767 CreateItemData::ReFungible(data) => {1768 let mut owner_list = Vec::new();1769 owner_list.push(Ownership {owner: owner.clone(), fraction: data.pieces});17701771 let item = ReFungibleItemType {1772 owner: owner_list,1773 const_data: data.const_data,1774 variable_data: data.variable_data1775 };17761777 Self::add_refungible_item(collection, item)?;1778 }1779 };17801781 Ok(())1782 }17831784 fn add_fungible_item(collection: &CollectionHandle<T>, owner: &T::CrossAccountId, value: u128) -> DispatchResult {1785 let collection_id = collection.id;17861787 // Does new owner already have an account?1788 let balance: u128 = <FungibleItemList<T>>::get(collection_id, owner.as_sub()).value;17891790 // Mint 1791 let item = FungibleItemType {1792 value: balance.checked_add(value).ok_or(Error::<T>::NumOverflow)?,1793 };1794 <FungibleItemList<T>>::insert(collection_id, owner.as_sub(), item);17951796 // Update balance1797 let new_balance = <Balance<T>>::get(collection_id, owner.as_sub())1798 .checked_add(value)1799 .ok_or(Error::<T>::NumOverflow)?;1800 <Balance<T>>::insert(collection_id, owner.as_sub(), new_balance);18011802 Self::deposit_event(RawEvent::ItemCreated(collection_id, 0, owner.clone()));1803 Ok(())1804 }18051806 fn add_refungible_item(collection: &CollectionHandle<T>, item: ReFungibleItemType<T::CrossAccountId>) -> DispatchResult {1807 let collection_id = collection.id;18081809 let current_index = <ItemListIndex>::get(collection_id)1810 .checked_add(1)1811 .ok_or(Error::<T>::NumOverflow)?;1812 let itemcopy = item.clone();18131814 ensure!(1815 item.owner.len() == 1,1816 Error::<T>::BadCreateRefungibleCall,1817 );1818 let item_owner = item.owner.first().expect("only one owner is defined");18191820 let value = item_owner.fraction;1821 let owner = item_owner.owner.clone();18221823 Self::add_token_index(collection_id, current_index, &owner)?;18241825 <ItemListIndex>::insert(collection_id, current_index);1826 <ReFungibleItemList<T>>::insert(collection_id, current_index, itemcopy);18271828 // Update balance1829 let new_balance = <Balance<T>>::get(collection_id, owner.as_sub())1830 .checked_add(value)1831 .ok_or(Error::<T>::NumOverflow)?;1832 <Balance<T>>::insert(collection_id, owner.as_sub(), new_balance);18331834 Self::deposit_event(RawEvent::ItemCreated(collection_id, current_index, owner));1835 Ok(())1836 }18371838 fn add_nft_item(collection: &CollectionHandle<T>, item: NftItemType<T::CrossAccountId>) -> DispatchResult {1839 let collection_id = collection.id;18401841 let current_index = <ItemListIndex>::get(collection_id)1842 .checked_add(1)1843 .ok_or(Error::<T>::NumOverflow)?;18441845 let item_owner = item.owner.clone();1846 Self::add_token_index(collection_id, current_index, &item.owner)?;18471848 <ItemListIndex>::insert(collection_id, current_index);1849 <NftItemList<T>>::insert(collection_id, current_index, item);18501851 // Update balance1852 let new_balance = <Balance<T>>::get(collection_id, item_owner.as_sub())1853 .checked_add(1)1854 .ok_or(Error::<T>::NumOverflow)?;1855 <Balance<T>>::insert(collection_id, item_owner.as_sub(), new_balance);18561857 collection.log(ERC721Events::Transfer {1858 from: H160::default(),1859 to: *item_owner.as_eth(),1860 token_id: current_index.into(),1861 });1862 Self::deposit_event(RawEvent::ItemCreated(collection_id, current_index, item_owner));1863 Ok(())1864 }18651866 fn burn_refungible_item(1867 collection: &CollectionHandle<T>,1868 item_id: TokenId,1869 owner: &T::CrossAccountId,1870 ) -> DispatchResult {1871 let collection_id = collection.id;18721873 let mut token = <ReFungibleItemList<T>>::get(collection_id, item_id)1874 .ok_or(Error::<T>::TokenNotFound)?;1875 let rft_balance = token1876 .owner1877 .iter()1878 .find(|&i| i.owner == *owner)1879 .ok_or(Error::<T>::TokenNotFound)?;1880 Self::remove_token_index(collection_id, item_id, owner)?;18811882 // update balance1883 let new_balance = <Balance<T>>::get(collection_id, rft_balance.owner.as_sub())1884 .checked_sub(rft_balance.fraction)1885 .ok_or(Error::<T>::NumOverflow)?;1886 <Balance<T>>::insert(collection_id, rft_balance.owner.as_sub(), new_balance);18871888 // Re-create owners list with sender removed1889 let index = token1890 .owner1891 .iter()1892 .position(|i| i.owner == *owner)1893 .expect("owned item is exists");1894 token.owner.remove(index);1895 let owner_count = token.owner.len();18961897 // Burn the token completely if this was the last (only) owner1898 if owner_count == 0 {1899 <ReFungibleItemList<T>>::remove(collection_id, item_id);1900 <VariableMetaDataBasket<T>>::remove(collection_id, item_id);1901 }1902 else {1903 <ReFungibleItemList<T>>::insert(collection_id, item_id, token);1904 }19051906 Ok(())1907 }19081909 fn burn_nft_item(collection: &CollectionHandle<T>, item_id: TokenId) -> DispatchResult {1910 let collection_id = collection.id;19111912 let item = <NftItemList<T>>::get(collection_id, item_id)1913 .ok_or(Error::<T>::TokenNotFound)?;1914 Self::remove_token_index(collection_id, item_id, &item.owner)?;19151916 // update balance1917 let new_balance = <Balance<T>>::get(collection_id, item.owner.as_sub())1918 .checked_sub(1)1919 .ok_or(Error::<T>::NumOverflow)?;1920 <Balance<T>>::insert(collection_id, item.owner.as_sub(), new_balance);1921 <NftItemList<T>>::remove(collection_id, item_id);1922 <VariableMetaDataBasket<T>>::remove(collection_id, item_id);19231924 Self::deposit_event(RawEvent::ItemDestroyed(collection.id, item_id));1925 Ok(())1926 }19271928 fn burn_fungible_item(owner: &T::CrossAccountId, collection: &CollectionHandle<T>, value: u128) -> DispatchResult {1929 let collection_id = collection.id;19301931 let mut balance = <FungibleItemList<T>>::get(collection_id, owner.as_sub());1932 ensure!(balance.value >= value, Error::<T>::TokenValueNotEnough);19331934 // update balance1935 let new_balance = <Balance<T>>::get(collection_id, owner.as_sub())1936 .checked_sub(value)1937 .ok_or(Error::<T>::NumOverflow)?;1938 <Balance<T>>::insert(collection_id, owner.as_sub(), new_balance);19391940 if balance.value - value > 0 {1941 balance.value -= value;1942 <FungibleItemList<T>>::insert(collection_id, owner.as_sub(), balance);1943 }1944 else {1945 <FungibleItemList<T>>::remove(collection_id, owner.as_sub());1946 }19471948 collection.log(ERC20Events::Transfer {1949 from: *owner.as_eth(),1950 to: H160::default(),1951 value: value.into(),1952 });1953 Ok(())1954 }19551956 pub fn get_collection(collection_id: CollectionId) -> Result<CollectionHandle<T>, sp_runtime::DispatchError> {1957 Ok(<CollectionHandle<T>>::get(collection_id)1958 .ok_or(Error::<T>::CollectionNotFound)?)1959 }19601961 fn save_collection(collection: CollectionHandle<T>) {1962 <CollectionById<T>>::insert(collection.id, collection.into_inner());1963 }19641965 pub fn submit_logs(collection: CollectionHandle<T>) -> DispatchResult {1966 if collection.logs.is_empty() {1967 return Ok(())1968 }1969 T::EthereumTransactionSender::submit_logs_transaction(1970 eth::generate_transaction(collection.id, T::EthereumChainId::get()),1971 collection.logs.retrieve_logs(),1972 )1973 }19741975 fn check_owner_permissions(target_collection: &CollectionHandle<T>, subject: &T::AccountId) -> DispatchResult {1976 ensure!(1977 *subject == target_collection.owner,1978 Error::<T>::NoPermission1979 );19801981 Ok(())1982 }19831984 fn is_owner_or_admin_permissions(collection: &CollectionHandle<T>, subject: &T::CrossAccountId) -> bool {1985 *subject.as_sub() == collection.owner || <AdminList<T>>::get(collection.id).contains(&subject)1986 }19871988 fn check_owner_or_admin_permissions(1989 collection: &CollectionHandle<T>,1990 subject: &T::CrossAccountId,1991 ) -> DispatchResult {1992 ensure!(Self::is_owner_or_admin_permissions(collection, subject), Error::<T>::NoPermission);19931994 Ok(())1995 }19961997 fn owned_amount(1998 subject: &T::CrossAccountId,1999 target_collection: &CollectionHandle<T>,2000 item_id: TokenId,2001 ) -> Option<u128> {2002 let collection_id = target_collection.id;20032004 match target_collection.mode {2005 CollectionMode::NFT => (<NftItemList<T>>::get(collection_id, item_id)?.owner == *subject)2006 .then(|| 1),2007 CollectionMode::Fungible(_) => Some(<FungibleItemList<T>>::get(collection_id, &subject.as_sub())2008 .value),2009 CollectionMode::ReFungible => <ReFungibleItemList<T>>::get(collection_id, item_id)?2010 .owner2011 .iter()2012 .find(|i| i.owner == *subject)2013 .map(|i| i.fraction),2014 CollectionMode::Invalid => None,2015 }2016 }20172018 fn is_item_owner(subject: &T::CrossAccountId, target_collection: &CollectionHandle<T>, item_id: TokenId) -> bool {2019 match target_collection.mode {2020 CollectionMode::Fungible(_) => true,2021 _ => Self::owned_amount(&subject, target_collection, item_id).is_some(),2022 }2023 }20242025 fn check_white_list(collection: &CollectionHandle<T>, address: &T::CrossAccountId) -> DispatchResult {2026 let collection_id = collection.id;20272028 let mes = Error::<T>::AddresNotInWhiteList;2029 ensure!(<WhiteList<T>>::contains_key(collection_id, address.as_sub()), mes);20302031 Ok(())2032 }20332034 /// Check if token exists. In case of Fungible, check if there is an entry for 2035 /// the owner in fungible balances double map2036 fn token_exists(2037 target_collection: &CollectionHandle<T>,2038 item_id: TokenId,2039 ) -> DispatchResult {2040 let collection_id = target_collection.id;2041 let exists = match target_collection.mode2042 {2043 CollectionMode::NFT => <NftItemList<T>>::contains_key(collection_id, item_id),2044 CollectionMode::Fungible(_) => true,2045 CollectionMode::ReFungible => <ReFungibleItemList<T>>::contains_key(collection_id, item_id),2046 _ => false2047 };20482049 ensure!(exists == true, Error::<T>::TokenNotFound);2050 Ok(())2051 }20522053 fn transfer_fungible(2054 collection: &CollectionHandle<T>,2055 value: u128,2056 owner: &T::CrossAccountId,2057 recipient: &T::CrossAccountId,2058 ) -> DispatchResult {2059 let collection_id = collection.id;20602061 let mut balance = <FungibleItemList<T>>::get(collection_id, owner.as_sub());2062 ensure!(balance.value >= value, Error::<T>::TokenValueTooLow);20632064 // Send balance to recipient (updates balanceOf of recipient)2065 Self::add_fungible_item(collection, recipient, value)?;20662067 // update balanceOf of sender2068 <Balance<T>>::insert(collection_id, owner.as_sub(), balance.value - value);20692070 // Reduce or remove sender2071 if balance.value == value {2072 <FungibleItemList<T>>::remove(collection_id, owner.as_sub());2073 }2074 else {2075 balance.value -= value;2076 <FungibleItemList<T>>::insert(collection_id, owner.as_sub(), balance);2077 }20782079 collection.log(ERC20Events::Transfer {2080 from: *owner.as_eth(),2081 to: *recipient.as_eth(),2082 value: value.into(),2083 });2084 Self::deposit_event(RawEvent::Transfer(collection.id, 1, owner.clone(), recipient.clone(), value));20852086 Ok(())2087 }20882089 fn transfer_refungible(2090 collection: &CollectionHandle<T>,2091 item_id: TokenId,2092 value: u128,2093 owner: T::CrossAccountId,2094 new_owner: T::CrossAccountId,2095 ) -> DispatchResult {2096 let collection_id = collection.id;2097 let full_item = <ReFungibleItemList<T>>::get(collection_id, item_id)2098 .ok_or(Error::<T>::TokenNotFound)?;20992100 let item = full_item2101 .owner2102 .iter()2103 .filter(|i| i.owner == owner)2104 .next()2105 .ok_or(Error::<T>::TokenNotFound)?;2106 let amount = item.fraction;21072108 ensure!(amount >= value, Error::<T>::TokenValueTooLow);21092110 // update balance2111 let balance_old_owner = <Balance<T>>::get(collection_id, item.owner.as_sub())2112 .checked_sub(value)2113 .ok_or(Error::<T>::NumOverflow)?;2114 <Balance<T>>::insert(collection_id, item.owner.as_sub(), balance_old_owner);21152116 let balance_new_owner = <Balance<T>>::get(collection_id, new_owner.as_sub())2117 .checked_add(value)2118 .ok_or(Error::<T>::NumOverflow)?;2119 <Balance<T>>::insert(collection_id, new_owner.as_sub(), balance_new_owner);21202121 let old_owner = item.owner.clone();2122 let new_owner_has_account = full_item.owner.iter().any(|i| i.owner == new_owner);21232124 // transfer2125 if amount == value && !new_owner_has_account {2126 // change owner2127 // new owner do not have account2128 let mut new_full_item = full_item.clone();2129 new_full_item2130 .owner2131 .iter_mut()2132 .find(|i| i.owner == owner)2133 .expect("old owner does present in refungible")2134 .owner = new_owner.clone();2135 <ReFungibleItemList<T>>::insert(collection_id, item_id, new_full_item);21362137 // update index collection2138 Self::move_token_index(collection_id, item_id, &old_owner, &new_owner)?;2139 } else {2140 let mut new_full_item = full_item.clone();2141 new_full_item2142 .owner2143 .iter_mut()2144 .find(|i| i.owner == owner)2145 .expect("old owner does present in refungible")2146 .fraction -= value;21472148 // separate amount2149 if new_owner_has_account {2150 // new owner has account2151 new_full_item2152 .owner2153 .iter_mut()2154 .find(|i| i.owner == new_owner)2155 .expect("new owner has account")2156 .fraction += value;2157 } else {2158 // new owner do not have account2159 new_full_item.owner.push(Ownership {2160 owner: new_owner.clone(),2161 fraction: value,2162 });2163 Self::add_token_index(collection_id, item_id, &new_owner)?;2164 }21652166 <ReFungibleItemList<T>>::insert(collection_id, item_id, new_full_item);2167 }21682169 Self::deposit_event(RawEvent::Transfer(collection.id, item_id, owner, new_owner, amount));21702171 Ok(())2172 }21732174 fn transfer_nft(2175 collection: &CollectionHandle<T>,2176 item_id: TokenId,2177 sender: T::CrossAccountId,2178 new_owner: T::CrossAccountId,2179 ) -> DispatchResult {2180 let collection_id = collection.id;2181 let mut item = <NftItemList<T>>::get(collection_id, item_id)2182 .ok_or(Error::<T>::TokenNotFound)?;21832184 ensure!(2185 sender == item.owner,2186 Error::<T>::MustBeTokenOwner2187 );21882189 // update balance2190 let balance_old_owner = <Balance<T>>::get(collection_id, item.owner.as_sub())2191 .checked_sub(1)2192 .ok_or(Error::<T>::NumOverflow)?;2193 <Balance<T>>::insert(collection_id, item.owner.as_sub(), balance_old_owner);21942195 let balance_new_owner = <Balance<T>>::get(collection_id, new_owner.as_sub())2196 .checked_add(1)2197 .ok_or(Error::<T>::NumOverflow)?;2198 <Balance<T>>::insert(collection_id, new_owner.as_sub(), balance_new_owner);21992200 // change owner2201 let old_owner = item.owner.clone();2202 item.owner = new_owner.clone();2203 <NftItemList<T>>::insert(collection_id, item_id, item);22042205 // update index collection2206 Self::move_token_index(collection_id, item_id, &old_owner, &new_owner)?;22072208 collection.log(ERC721Events::Transfer {2209 from: *sender.as_eth(),2210 to: *new_owner.as_eth(),2211 token_id: item_id.into(),2212 });2213 Self::deposit_event(RawEvent::Transfer(collection.id, item_id, sender, new_owner, 1));22142215 Ok(())2216 }2217 2218 fn set_re_fungible_variable_data(2219 collection: &CollectionHandle<T>,2220 item_id: TokenId,2221 data: Vec<u8>2222 ) -> DispatchResult {2223 let collection_id = collection.id;2224 let mut item = <ReFungibleItemList<T>>::get(collection_id, item_id)2225 .ok_or(Error::<T>::TokenNotFound)?;22262227 item.variable_data = data;22282229 <ReFungibleItemList<T>>::insert(collection_id, item_id, item);22302231 Ok(())2232 }22332234 fn set_nft_variable_data(2235 collection: &CollectionHandle<T>,2236 item_id: TokenId,2237 data: Vec<u8>2238 ) -> DispatchResult {2239 let collection_id = collection.id;2240 let mut item = <NftItemList<T>>::get(collection_id, item_id)2241 .ok_or(Error::<T>::TokenNotFound)?;2242 2243 item.variable_data = data;22442245 <NftItemList<T>>::insert(collection_id, item_id, item);2246 2247 Ok(())2248 }22492250 #[allow(dead_code)]2251 fn init_collection(item: &Collection<T>) {2252 // check params2253 assert!(2254 item.decimal_points <= MAX_DECIMAL_POINTS,2255 "decimal_points parameter must be lower than MAX_DECIMAL_POINTS"2256 );2257 assert!(2258 item.name.len() <= 64,2259 "Collection name can not be longer than 63 char"2260 );2261 assert!(2262 item.name.len() <= 256,2263 "Collection description can not be longer than 255 char"2264 );2265 assert!(2266 item.token_prefix.len() <= 16,2267 "Token prefix can not be longer than 15 char"2268 );22692270 // Generate next collection ID2271 let next_id = CreatedCollectionCount::get()2272 .checked_add(1)2273 .unwrap();22742275 CreatedCollectionCount::put(next_id);2276 }22772278 #[allow(dead_code)]2279 fn init_nft_token(collection_id: CollectionId, item: &NftItemType<T::CrossAccountId>) {2280 let current_index = <ItemListIndex>::get(collection_id)2281 .checked_add(1)2282 .unwrap();22832284 Self::add_token_index(collection_id, current_index, &item.owner).unwrap();22852286 <ItemListIndex>::insert(collection_id, current_index);22872288 // Update balance2289 let new_balance = <Balance<T>>::get(collection_id, item.owner.as_sub())2290 .checked_add(1)2291 .unwrap();2292 <Balance<T>>::insert(collection_id, item.owner.as_sub(), new_balance);2293 }22942295 #[allow(dead_code)]2296 fn init_fungible_token(collection_id: CollectionId, owner: &T::CrossAccountId, item: &FungibleItemType) {2297 let current_index = <ItemListIndex>::get(collection_id)2298 .checked_add(1)2299 .unwrap();23002301 Self::add_token_index(collection_id, current_index, owner).unwrap();23022303 <ItemListIndex>::insert(collection_id, current_index);23042305 // Update balance2306 let new_balance = <Balance<T>>::get(collection_id, owner.as_sub())2307 .checked_add(item.value)2308 .unwrap();2309 <Balance<T>>::insert(collection_id, owner.as_sub(), new_balance);2310 }23112312 #[allow(dead_code)]2313 fn init_refungible_token(collection_id: CollectionId, item: &ReFungibleItemType<T::CrossAccountId>) {2314 let current_index = <ItemListIndex>::get(collection_id)2315 .checked_add(1)2316 .unwrap();23172318 let value = item.owner.first().unwrap().fraction;2319 let owner = item.owner.first().unwrap().owner.clone();23202321 Self::add_token_index(collection_id, current_index, &owner).unwrap();23222323 <ItemListIndex>::insert(collection_id, current_index);23242325 // Update balance2326 let new_balance = <Balance<T>>::get(collection_id, &owner.as_sub())2327 .checked_add(value)2328 .unwrap();2329 <Balance<T>>::insert(collection_id, owner.as_sub(), new_balance);2330 }23312332 fn add_token_index(collection_id: CollectionId, item_index: TokenId, owner: &T::CrossAccountId) -> DispatchResult {2333 // add to account limit2334 if <AccountItemCount<T>>::contains_key(owner.as_sub()) {23352336 // bound Owned tokens by a single address2337 let count = <AccountItemCount<T>>::get(owner.as_sub());2338 ensure!(count < ChainLimit::get().account_token_ownership_limit, Error::<T>::AddressOwnershipLimitExceeded);23392340 <AccountItemCount<T>>::insert(owner.as_sub(), count2341 .checked_add(1)2342 .ok_or(Error::<T>::NumOverflow)?);2343 }2344 else {2345 <AccountItemCount<T>>::insert(owner.as_sub(), 1);2346 }23472348 let list_exists = <AddressTokens<T>>::contains_key(collection_id, owner.as_sub());2349 if list_exists {2350 let mut list = <AddressTokens<T>>::get(collection_id, owner.as_sub());2351 let item_contains = list.contains(&item_index.clone());23522353 if !item_contains {2354 list.push(item_index.clone());2355 }23562357 <AddressTokens<T>>::insert(collection_id, owner.as_sub(), list);2358 } else {2359 let mut itm = Vec::new();2360 itm.push(item_index.clone());2361 <AddressTokens<T>>::insert(collection_id, owner.as_sub(), itm);2362 }23632364 Ok(())2365 }23662367 fn remove_token_index(2368 collection_id: CollectionId,2369 item_index: TokenId,2370 owner: &T::CrossAccountId,2371 ) -> DispatchResult {23722373 // update counter2374 <AccountItemCount<T>>::insert(owner.as_sub(), 2375 <AccountItemCount<T>>::get(owner.as_sub())2376 .checked_sub(1)2377 .ok_or(Error::<T>::NumOverflow)?);237823792380 let list_exists = <AddressTokens<T>>::contains_key(collection_id, owner.as_sub());2381 if list_exists {2382 let mut list = <AddressTokens<T>>::get(collection_id, owner.as_sub());2383 let item_contains = list.contains(&item_index.clone());23842385 if item_contains {2386 list.retain(|&item| item != item_index);2387 <AddressTokens<T>>::insert(collection_id, owner.as_sub(), list);2388 }2389 }23902391 Ok(())2392 }23932394 fn move_token_index(2395 collection_id: CollectionId,2396 item_index: TokenId,2397 old_owner: &T::CrossAccountId,2398 new_owner: &T::CrossAccountId,2399 ) -> DispatchResult {2400 Self::remove_token_index(collection_id, item_index, old_owner)?;2401 Self::add_token_index(collection_id, item_index, new_owner)?;24022403 Ok(())2404 }2405 2406 fn ensure_contract_owned(account: T::AccountId, contract: &T::AccountId) -> DispatchResult {2407 ensure!(<ContractOwner<T>>::get(contract) == Some(account), Error::<T>::NoPermission);24082409 Ok(())2410 }2411}24122413sp_api::decl_runtime_apis! {2414 pub trait NftApi {2415 /// Used for ethereum integration2416 fn eth_contract_code(account: H160) -> Option<Vec<u8>>;2417 }2418}1//2// This file is subject to the terms and conditions defined in3// file 'LICENSE', which is part of this source code package.4//56#![recursion_limit = "1024"]78#![cfg_attr(not(feature = "std"), no_std)]910extern crate alloc;1112pub use serde::{Serialize, Deserialize};1314pub use frame_support::{15 construct_runtime, decl_event, decl_module, decl_storage, decl_error,16 dispatch::DispatchResult,17 ensure, fail, parameter_types,18 traits::{19 Currency, ExistenceRequirement, Get, Imbalance, KeyOwnerProofSystem, OnUnbalanced,20 Randomness, IsSubType, WithdrawReasons,21 },22 weights::{23 constants::{BlockExecutionWeight, ExtrinsicBaseWeight, RocksDbWeight, WEIGHT_PER_SECOND},24 DispatchInfo, GetDispatchInfo, IdentityFee, Pays, PostDispatchInfo, Weight,25 WeightToFeePolynomial, DispatchClass,26 },27 StorageValue,28 transactional,29};3031use frame_system::{self as system, ensure_signed, ensure_root};32use sp_core::H160;33use sp_runtime::sp_std::prelude::Vec;34use core::ops::{Deref, DerefMut};35use core::cell::RefCell;36use nft_data_structs::{37 MAX_DECIMAL_POINTS, MAX_SPONSOR_TIMEOUT, MAX_TOKEN_OWNERSHIP, MAX_REFUNGIBLE_PIECES,38 AccessMode, ChainLimits, Collection, CreateItemData, CollectionLimits,39 CollectionId, CollectionMode, TokenId, 40 SchemaVersion, SponsorshipState, Ownership,41 NftItemType, FungibleItemType, ReFungibleItemType42};43use pallet_ethereum::EthereumTransactionSender;4445#[cfg(test)]46mod mock;4748#[cfg(test)]49mod tests;5051mod default_weights;52mod eth;5354pub use eth::NftErcSupport;55pub use eth::account::*;56use eth::erc::{ERC20Events, ERC721Events};5758#[cfg(feature = "runtime-benchmarks")]59mod benchmarking;6061pub trait WeightInfo {62 fn create_collection() -> Weight;63 fn destroy_collection() -> Weight;64 fn add_to_white_list() -> Weight;65 fn remove_from_white_list() -> Weight;66 fn set_public_access_mode() -> Weight;67 fn set_mint_permission() -> Weight;68 fn change_collection_owner() -> Weight;69 fn add_collection_admin() -> Weight;70 fn remove_collection_admin() -> Weight;71 fn set_collection_sponsor() -> Weight;72 fn confirm_sponsorship() -> Weight;73 fn remove_collection_sponsor() -> Weight;74 fn create_item(s: usize) -> Weight;75 fn burn_item() -> Weight;76 fn transfer() -> Weight;77 fn approve() -> Weight;78 fn transfer_from() -> Weight;79 fn set_offchain_schema() -> Weight;80 fn set_const_on_chain_schema() -> Weight;81 fn set_variable_on_chain_schema() -> Weight;82 fn set_variable_meta_data() -> Weight;83 fn enable_contract_sponsoring() -> Weight;84 fn set_schema_version() -> Weight;85 fn set_chain_limits() -> Weight;86 fn set_contract_sponsoring_rate_limit() -> Weight;87 fn set_variable_meta_data_sponsoring_rate_limit() -> Weight;88 fn toggle_contract_white_list() -> Weight;89 fn add_to_contract_white_list() -> Weight;90 fn remove_from_contract_white_list() -> Weight;91 fn set_collection_limits() -> Weight;92}9394decl_error! {95 /// Error for non-fungible-token module.96 pub enum Error for Module<T: Config> {97 /// Total collections bound exceeded.98 TotalCollectionsLimitExceeded,99 /// Decimal_points parameter must be lower than MAX_DECIMAL_POINTS constant, currently it is 30.100 CollectionDecimalPointLimitExceeded, 101 /// Collection name can not be longer than 63 char.102 CollectionNameLimitExceeded, 103 /// Collection description can not be longer than 255 char.104 CollectionDescriptionLimitExceeded, 105 /// Token prefix can not be longer than 15 char.106 CollectionTokenPrefixLimitExceeded,107 /// This collection does not exist.108 CollectionNotFound,109 /// Item not exists.110 TokenNotFound,111 /// Admin not found112 AdminNotFound,113 /// Arithmetic calculation overflow.114 NumOverflow, 115 /// Account already has admin role.116 AlreadyAdmin, 117 /// You do not own this collection.118 NoPermission,119 /// This address is not set as sponsor, use setCollectionSponsor first.120 ConfirmUnsetSponsorFail,121 /// Collection is not in mint mode.122 PublicMintingNotAllowed,123 /// Sender parameter and item owner must be equal.124 MustBeTokenOwner,125 /// Item balance not enough.126 TokenValueTooLow,127 /// Size of item is too large.128 NftSizeLimitExceeded,129 /// No approve found130 ApproveNotFound,131 /// Requested value more than approved.132 TokenValueNotEnough,133 /// Only approved addresses can call this method.134 ApproveRequired,135 /// Address is not in white list.136 AddresNotInWhiteList,137 /// Number of collection admins bound exceeded.138 CollectionAdminsLimitExceeded,139 /// Owned tokens by a single address bound exceeded.140 AddressOwnershipLimitExceeded,141 /// Length of items properties must be greater than 0.142 EmptyArgument,143 /// const_data exceeded data limit.144 TokenConstDataLimitExceeded,145 /// variable_data exceeded data limit.146 TokenVariableDataLimitExceeded,147 /// Not NFT item data used to mint in NFT collection.148 NotNftDataUsedToMintNftCollectionToken,149 /// Not Fungible item data used to mint in Fungible collection.150 NotFungibleDataUsedToMintFungibleCollectionToken,151 /// Not Re Fungible item data used to mint in Re Fungible collection.152 NotReFungibleDataUsedToMintReFungibleCollectionToken,153 /// Unexpected collection type.154 UnexpectedCollectionType,155 /// Can't store metadata in fungible tokens.156 CantStoreMetadataInFungibleTokens,157 /// Collection token limit exceeded158 CollectionTokenLimitExceeded,159 /// Account token limit exceeded per collection160 AccountTokenLimitExceeded,161 /// Collection limit bounds per collection exceeded162 CollectionLimitBoundsExceeded,163 /// Tried to enable permissions which are only permitted to be disabled164 OwnerPermissionsCantBeReverted,165 /// Schema data size limit bound exceeded166 SchemaDataLimitExceeded,167 /// Maximum refungibility exceeded168 WrongRefungiblePieces,169 /// createRefungible should be called with one owner170 BadCreateRefungibleCall,171 /// Gas limit exceeded172 OutOfGas,173 }174}175176pub struct CollectionHandle<T: Config> {177 pub id: CollectionId,178 collection: Collection<T>,179 logs: eth::log::LogRecorder,180 evm_address: H160,181 gas_limit: RefCell<u64>,182}183impl<T: Config> CollectionHandle<T> {184 pub fn get_with_gas_limit(id: CollectionId, gas_limit: u64) -> Option<Self> {185 <CollectionById<T>>::get(id)186 .map(|collection| Self {187 id,188 collection,189 logs: eth::log::LogRecorder::default(),190 evm_address: eth::collection_id_to_address(id),191 gas_limit: RefCell::new(gas_limit),192 })193 }194 pub fn get(id: CollectionId) -> Option<Self> {195 Self::get_with_gas_limit(id, u64::MAX)196 }197 pub fn gas_left(&self) -> u64 {198 *self.gas_limit.borrow()199 }200 pub fn consume_gas(&self, gas: u64) -> DispatchResult {201 let mut gas_limit = self.gas_limit.borrow_mut();202 if *gas_limit < gas {203 fail!(Error::<T>::OutOfGas);204 }205 *gas_limit -= gas;206 Ok(())207 }208 pub fn log(&self, log: impl evm_coder::ToLog) {209 self.logs.log(log.to_log(self.evm_address))210 }211 pub fn into_inner(self) -> Collection<T> {212 self.collection.clone()213 }214}215impl<T: Config> Deref for CollectionHandle<T> {216 type Target = Collection<T>;217218 fn deref(&self) -> &Self::Target {219 &self.collection220 }221}222223impl<T: Config> DerefMut for CollectionHandle<T> {224 fn deref_mut(&mut self) -> &mut Self::Target {225 &mut self.collection226 }227}228229pub trait Config: system::Config + Sized {230 type Event: From<Event<Self>> + Into<<Self as system::Config>::Event>;231232 /// Weight information for extrinsics in this pallet.233 type WeightInfo: WeightInfo;234235 type EvmAddressMapping: pallet_evm::AddressMapping<Self::AccountId>;236 type EvmBackwardsAddressMapping: EvmBackwardsAddressMapping<Self::AccountId>;237 type EvmWithdrawOrigin: pallet_evm::EnsureAddressOrigin<Self::Origin, Success = Self::AccountId>;238239 type CrossAccountId: CrossAccountId<Self::AccountId>;240 type Currency: Currency<Self::AccountId>;241 type CollectionCreationPrice: Get<<<Self as Config>::Currency as Currency<Self::AccountId>>::Balance>;242 type TreasuryAccountId: Get<Self::AccountId>;243244 type EthereumChainId: Get<u64>;245 type EthereumTransactionSender: pallet_ethereum::EthereumTransactionSender;246}247248// # Used definitions249//250// ## User control levels251//252// chain-controlled - key is uncontrolled by user253// i.e autoincrementing index254// can use non-cryptographic hash255// real - key is controlled by user256// but it is hard to generate enough colliding values, i.e owner of signed txs257// can use non-cryptographic hash258// controlled - key is completly controlled by users259// i.e maps with mutable keys260// should use cryptographic hash261//262// ## User control level downgrade reasons263//264// ?1 - chain-controlled -> controlled265// collections/tokens can be destroyed, resulting in massive holes266// ?2 - chain-controlled -> controlled267// same as ?1, but can be only added, resulting in easier exploitation268// ?3 - real -> controlled269// no confirmation required, so addresses can be easily generated270decl_storage! {271 trait Store for Module<T: Config> as Nft {272273 //#region Private members274 /// Id of next collection275 CreatedCollectionCount: u32;276 /// Used for migrations277 ChainVersion: u64;278 /// Id of last collection token279 /// Collection id (controlled?1)280 ItemListIndex: map hasher(blake2_128_concat) CollectionId => TokenId;281 //#endregion282283 //#region Chain limits struct284 pub ChainLimit get(fn chain_limit) config(): ChainLimits;285 //#endregion286287 //#region Bound counters288 /// Amount of collections destroyed, used for total amount tracking with289 /// CreatedCollectionCount290 DestroyedCollectionCount: u32;291 /// Total amount of account owned tokens (NFTs + RFTs + unique fungibles)292 /// Account id (real)293 pub AccountItemCount get(fn account_item_count): map hasher(twox_64_concat) T::AccountId => u32;294 //#endregion295296 //#region Basic collections297 /// Collection info298 /// Collection id (controlled?1)299 pub CollectionById get(fn collection_id) config(): map hasher(blake2_128_concat) CollectionId => Option<Collection<T>> = None;300 /// List of collection admins301 /// Collection id (controlled?2)302 pub AdminList get(fn admin_list_collection): map hasher(blake2_128_concat) CollectionId => Vec<T::CrossAccountId>;303 /// Whitelisted collection users304 /// Collection id (controlled?2), user id (controlled?3)305 pub WhiteList get(fn white_list): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) T::AccountId => bool;306 //#endregion307308 /// How many of collection items user have309 /// Collection id (controlled?2), account id (real)310 pub Balance get(fn balance_count): double_map hasher(blake2_128_concat) CollectionId, hasher(twox_64_concat) T::AccountId => u128;311312 /// Amount of items which spender can transfer out of owners account (via transferFrom)313 /// Collection id (controlled?2), (token id (controlled ?2) + owner account id (real) + spender account id (controlled?3))314 /// TODO: Off chain worker should remove from this map when token gets removed315 pub Allowances get(fn approved): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) (TokenId, T::AccountId, T::AccountId) => u128;316317 //#region Item collections318 /// Collection id (controlled?2), token id (controlled?1)319 pub NftItemList get(fn nft_item_id) config(): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => Option<NftItemType<T::CrossAccountId>>;320 /// Collection id (controlled?2), owner (controlled?2)321 pub FungibleItemList get(fn fungible_item_id) config(): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) T::AccountId => FungibleItemType;322 /// Collection id (controlled?2), token id (controlled?1)323 pub ReFungibleItemList get(fn refungible_item_id) config(): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => Option<ReFungibleItemType<T::CrossAccountId>>;324 //#endregion325326 //#region Index list327 /// Collection id (controlled?2), tokens owner (controlled?2)328 pub AddressTokens get(fn address_tokens): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) T::AccountId => Vec<TokenId>;329 //#endregion330331 //#region Tokens transfer rate limit baskets332 /// (Collection id (controlled?2), who created (real))333 /// TODO: Off chain worker should remove from this map when collection gets removed334 pub CreateItemBasket get(fn create_item_basket): map hasher(blake2_128_concat) (CollectionId, T::AccountId) => T::BlockNumber;335 /// Collection id (controlled?2), token id (controlled?2)336 pub NftTransferBasket get(fn nft_transfer_basket): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => T::BlockNumber;337 /// Collection id (controlled?2), owning user (real)338 pub FungibleTransferBasket get(fn fungible_transfer_basket): double_map hasher(blake2_128_concat) CollectionId, hasher(twox_64_concat) T::AccountId => T::BlockNumber;339 /// Collection id (controlled?2), token id (controlled?2)340 pub ReFungibleTransferBasket get(fn refungible_transfer_basket): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => T::BlockNumber;341 //#endregion342343 /// Variable metadata sponsoring344 /// Collection id (controlled?2), token id (controlled?2)345 pub VariableMetaDataBasket get(fn variable_meta_data_basket): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => Option<T::BlockNumber> = None;346 }347 add_extra_genesis {348 build(|config: &GenesisConfig<T>| {349 // Modification of storage350 for (_num, _c) in &config.collection_id {351 <Module<T>>::init_collection(_c);352 }353354 for (_num, _c, _i) in &config.nft_item_id {355 <Module<T>>::init_nft_token(*_c, _i);356 }357358 for (collection_id, account_id, fungible_item) in &config.fungible_item_id {359 <Module<T>>::init_fungible_token(*collection_id, &T::CrossAccountId::from_sub(account_id.clone()), fungible_item);360 }361362 for (_num, _c, _i) in &config.refungible_item_id {363 <Module<T>>::init_refungible_token(*_c, _i);364 }365 })366 }367}368369decl_event!(370 pub enum Event<T>371 where372 AccountId = <T as frame_system::Config>::AccountId,373 CrossAccountId = <T as Config>::CrossAccountId,374 {375 /// New collection was created376 /// 377 /// # Arguments378 /// 379 /// * collection_id: Globally unique identifier of newly created collection.380 /// 381 /// * mode: [CollectionMode] converted into u8.382 /// 383 /// * account_id: Collection owner.384 CollectionCreated(CollectionId, u8, AccountId),385386 /// New item was created.387 /// 388 /// # Arguments389 /// 390 /// * collection_id: Id of the collection where item was created.391 /// 392 /// * item_id: Id of an item. Unique within the collection.393 ///394 /// * recipient: Owner of newly created item 395 ItemCreated(CollectionId, TokenId, CrossAccountId),396397 /// Collection item was burned.398 /// 399 /// # Arguments400 /// 401 /// collection_id.402 /// 403 /// item_id: Identifier of burned NFT.404 ItemDestroyed(CollectionId, TokenId),405406 /// Item was transferred407 ///408 /// * collection_id: Id of collection to which item is belong409 ///410 /// * item_id: Id of an item411 ///412 /// * sender: Original owner of item413 ///414 /// * recipient: New owner of item415 ///416 /// * amount: Always 1 for NFT417 Transfer(CollectionId, TokenId, CrossAccountId, CrossAccountId, u128),418419 /// * collection_id420 ///421 /// * item_id422 ///423 /// * sender424 ///425 /// * spender426 ///427 /// * amount428 Approved(CollectionId, TokenId, CrossAccountId, CrossAccountId, u128),429 }430);431432decl_module! {433 pub struct Module<T: Config> for enum Call 434 where 435 origin: T::Origin436 {437 fn deposit_event() = default;438 type Error = Error<T>;439440 fn on_initialize(_now: T::BlockNumber) -> Weight {441 0442 }443444 /// This method creates a Collection of NFTs. Each Token may have multiple properties encoded as an array of bytes of certain length. The initial owner and admin of the collection are set to the address that signed the transaction. Both addresses can be changed later.445 /// 446 /// # Permissions447 /// 448 /// * Anyone.449 /// 450 /// # Arguments451 /// 452 /// * collection_name: UTF-16 string with collection name (limit 64 characters), will be stored as zero-terminated.453 /// 454 /// * collection_description: UTF-16 string with collection description (limit 256 characters), will be stored as zero-terminated.455 /// 456 /// * token_prefix: UTF-8 string with token prefix.457 /// 458 /// * mode: [CollectionMode] collection type and type dependent data.459 // returns collection ID460 #[weight = <T as Config>::WeightInfo::create_collection()]461 #[transactional]462 pub fn create_collection(origin,463 collection_name: Vec<u16>,464 collection_description: Vec<u16>,465 token_prefix: Vec<u8>,466 mode: CollectionMode) -> DispatchResult {467468 // Anyone can create a collection469 let who = ensure_signed(origin)?;470471 // Take a (non-refundable) deposit of collection creation472 let mut imbalance = <<<T as Config>::Currency as Currency<T::AccountId>>::PositiveImbalance>::zero();473 imbalance.subsume(<<T as Config>::Currency as Currency<T::AccountId>>::deposit_creating(474 &T::TreasuryAccountId::get(),475 T::CollectionCreationPrice::get(),476 ));477 <T as Config>::Currency::settle(478 &who,479 imbalance,480 WithdrawReasons::TRANSFER,481 ExistenceRequirement::KeepAlive,482 ).map_err(|_| Error::<T>::NoPermission)?;483484 let decimal_points = match mode {485 CollectionMode::Fungible(points) => points,486 _ => 0487 };488489 let chain_limit = ChainLimit::get();490491 let created_count = CreatedCollectionCount::get();492 let destroyed_count = DestroyedCollectionCount::get();493494 // bound Total number of collections495 ensure!(created_count - destroyed_count < chain_limit.collection_numbers_limit, Error::<T>::TotalCollectionsLimitExceeded);496497 // check params498 ensure!(decimal_points <= MAX_DECIMAL_POINTS, Error::<T>::CollectionDecimalPointLimitExceeded);499 ensure!(collection_name.len() <= 64, Error::<T>::CollectionNameLimitExceeded);500 ensure!(collection_description.len() <= 256, Error::<T>::CollectionDescriptionLimitExceeded);501 ensure!(token_prefix.len() <= 16, Error::<T>::CollectionTokenPrefixLimitExceeded);502503 // Generate next collection ID504 let next_id = created_count505 .checked_add(1)506 .ok_or(Error::<T>::NumOverflow)?;507508 CreatedCollectionCount::put(next_id);509510 let limits = CollectionLimits {511 sponsored_data_size: chain_limit.custom_data_limit,512 ..Default::default()513 };514515 // Create new collection516 let new_collection = Collection {517 owner: who.clone(),518 name: collection_name,519 mode: mode.clone(),520 mint_mode: false,521 access: AccessMode::Normal,522 description: collection_description,523 decimal_points: decimal_points,524 token_prefix: token_prefix,525 offchain_schema: Vec::new(),526 schema_version: SchemaVersion::ImageURL,527 sponsorship: SponsorshipState::Disabled,528 variable_on_chain_schema: Vec::new(),529 const_on_chain_schema: Vec::new(),530 limits,531 };532533 // Add new collection to map534 <CollectionById<T>>::insert(next_id, new_collection);535536 // call event537 Self::deposit_event(RawEvent::CollectionCreated(next_id, mode.into(), who));538539 Ok(())540 }541542 /// **DANGEROUS**: Destroys collection and all NFTs within this collection. Users irrecoverably lose their assets and may lose real money.543 /// 544 /// # Permissions545 /// 546 /// * Collection Owner.547 /// 548 /// # Arguments549 /// 550 /// * collection_id: collection to destroy.551 #[weight = <T as Config>::WeightInfo::destroy_collection()]552 #[transactional]553 pub fn destroy_collection(origin, collection_id: CollectionId) -> DispatchResult {554555 let sender = ensure_signed(origin)?;556 let collection = Self::get_collection(collection_id)?;557 Self::check_owner_permissions(&collection, &sender)?;558 if !collection.limits.owner_can_destroy {559 fail!(Error::<T>::NoPermission);560 }561562 <AddressTokens<T>>::remove_prefix(collection_id);563 <Allowances<T>>::remove_prefix(collection_id);564 <Balance<T>>::remove_prefix(collection_id);565 <ItemListIndex>::remove(collection_id);566 <AdminList<T>>::remove(collection_id);567 <CollectionById<T>>::remove(collection_id);568 <WhiteList<T>>::remove_prefix(collection_id);569570 <NftItemList<T>>::remove_prefix(collection_id);571 <FungibleItemList<T>>::remove_prefix(collection_id);572 <ReFungibleItemList<T>>::remove_prefix(collection_id);573574 <NftTransferBasket<T>>::remove_prefix(collection_id);575 <FungibleTransferBasket<T>>::remove_prefix(collection_id);576 <ReFungibleTransferBasket<T>>::remove_prefix(collection_id);577578 <VariableMetaDataBasket<T>>::remove_prefix(collection_id);579580 DestroyedCollectionCount::put(DestroyedCollectionCount::get()581 .checked_add(1)582 .ok_or(Error::<T>::NumOverflow)?);583584 Ok(())585 }586587 /// Add an address to white list.588 /// 589 /// # Permissions590 /// 591 /// * Collection Owner592 /// * Collection Admin593 /// 594 /// # Arguments595 /// 596 /// * collection_id.597 /// 598 /// * address.599 #[weight = <T as Config>::WeightInfo::add_to_white_list()]600 #[transactional]601 pub fn add_to_white_list(origin, collection_id: CollectionId, address: T::CrossAccountId) -> DispatchResult{602603 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);604 let collection = Self::get_collection(collection_id)?;605606 Self::toggle_white_list_internal(607 &sender,608 &collection,609 &address,610 true,611 )?;612613 Ok(())614 }615616 /// Remove an address from white list.617 /// 618 /// # Permissions619 /// 620 /// * Collection Owner621 /// * Collection Admin622 /// 623 /// # Arguments624 /// 625 /// * collection_id.626 /// 627 /// * address.628 #[weight = <T as Config>::WeightInfo::remove_from_white_list()]629 #[transactional]630 pub fn remove_from_white_list(origin, collection_id: CollectionId, address: T::CrossAccountId) -> DispatchResult{631632 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);633 let collection = Self::get_collection(collection_id)?;634635 Self::toggle_white_list_internal(636 &sender,637 &collection,638 &address,639 false,640 )?;641642 Ok(())643 }644645 /// Toggle between normal and white list access for the methods with access for `Anyone`.646 /// 647 /// # Permissions648 /// 649 /// * Collection Owner.650 /// 651 /// # Arguments652 /// 653 /// * collection_id.654 /// 655 /// * mode: [AccessMode]656 #[weight = <T as Config>::WeightInfo::set_public_access_mode()]657 #[transactional]658 pub fn set_public_access_mode(origin, collection_id: CollectionId, mode: AccessMode) -> DispatchResult659 {660 let sender = ensure_signed(origin)?;661662 let mut target_collection = Self::get_collection(collection_id)?;663 Self::check_owner_permissions(&target_collection, &sender)?;664 target_collection.access = mode;665 Self::save_collection(target_collection);666667 Ok(())668 }669670 /// Allows Anyone to create tokens if:671 /// * White List is enabled, and672 /// * Address is added to white list, and673 /// * This method was called with True parameter674 /// 675 /// # Permissions676 /// * Collection Owner677 ///678 /// # Arguments679 /// 680 /// * collection_id.681 /// 682 /// * mint_permission: Boolean parameter. If True, allows minting to Anyone with conditions above.683 #[weight = <T as Config>::WeightInfo::set_mint_permission()]684 #[transactional]685 pub fn set_mint_permission(origin, collection_id: CollectionId, mint_permission: bool) -> DispatchResult686 {687 let sender = ensure_signed(origin)?;688689 let mut target_collection = Self::get_collection(collection_id)?;690 Self::check_owner_permissions(&target_collection, &sender)?;691 target_collection.mint_mode = mint_permission;692 Self::save_collection(target_collection);693694 Ok(())695 }696697 /// Change the owner of the collection.698 /// 699 /// # Permissions700 /// 701 /// * Collection Owner.702 /// 703 /// # Arguments704 /// 705 /// * collection_id.706 /// 707 /// * new_owner.708 #[weight = <T as Config>::WeightInfo::change_collection_owner()]709 #[transactional]710 pub fn change_collection_owner(origin, collection_id: CollectionId, new_owner: T::AccountId) -> DispatchResult {711712 let sender = ensure_signed(origin)?;713 let mut target_collection = Self::get_collection(collection_id)?;714 Self::check_owner_permissions(&target_collection, &sender)?;715 target_collection.owner = new_owner;716 Self::save_collection(target_collection);717718 Ok(())719 }720721 /// Adds an admin of the Collection.722 /// NFT Collection can be controlled by multiple admin addresses (some which can also be servers, for example). Admins can issue and burn NFTs, as well as add and remove other admins, but cannot change NFT or Collection ownership. 723 /// 724 /// # Permissions725 /// 726 /// * Collection Owner.727 /// * Collection Admin.728 /// 729 /// # Arguments730 /// 731 /// * collection_id: ID of the Collection to add admin for.732 /// 733 /// * new_admin_id: Address of new admin to add.734 #[weight = <T as Config>::WeightInfo::add_collection_admin()]735 #[transactional]736 pub fn add_collection_admin(origin, collection_id: CollectionId, new_admin_id: T::CrossAccountId) -> DispatchResult {737 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);738 let collection = Self::get_collection(collection_id)?;739 Self::check_owner_or_admin_permissions(&collection, &sender)?;740 let mut admin_arr = <AdminList<T>>::get(collection_id);741742 match admin_arr.binary_search(&new_admin_id) {743 Ok(_) => {},744 Err(idx) => {745 let limits = ChainLimit::get();746 ensure!(admin_arr.len() < limits.collections_admins_limit as usize, Error::<T>::CollectionAdminsLimitExceeded);747 admin_arr.insert(idx, new_admin_id);748 <AdminList<T>>::insert(collection_id, admin_arr);749 }750 }751 Ok(())752 }753754 /// Remove admin address of the Collection. An admin address can remove itself. List of admins may become empty, in which case only Collection Owner will be able to add an Admin.755 ///756 /// # Permissions757 /// 758 /// * Collection Owner.759 /// * Collection Admin.760 /// 761 /// # Arguments762 /// 763 /// * collection_id: ID of the Collection to remove admin for.764 /// 765 /// * account_id: Address of admin to remove.766 #[weight = <T as Config>::WeightInfo::remove_collection_admin()]767 #[transactional]768 pub fn remove_collection_admin(origin, collection_id: CollectionId, account_id: T::CrossAccountId) -> DispatchResult {769 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);770 let collection = Self::get_collection(collection_id)?;771 Self::check_owner_or_admin_permissions(&collection, &sender)?;772 let mut admin_arr = <AdminList<T>>::get(collection_id);773774 match admin_arr.binary_search(&account_id) {775 Ok(idx) => {776 admin_arr.remove(idx);777 <AdminList<T>>::insert(collection_id, admin_arr);778 },779 Err(_) => {}780 }781 Ok(())782 }783784 /// # Permissions785 /// 786 /// * Collection Owner787 /// 788 /// # Arguments789 /// 790 /// * collection_id.791 /// 792 /// * new_sponsor.793 #[weight = <T as Config>::WeightInfo::set_collection_sponsor()]794 #[transactional]795 pub fn set_collection_sponsor(origin, collection_id: CollectionId, new_sponsor: T::AccountId) -> DispatchResult {796 let sender = ensure_signed(origin)?;797 let mut target_collection = Self::get_collection(collection_id)?;798 Self::check_owner_permissions(&target_collection, &sender)?;799800 target_collection.sponsorship = SponsorshipState::Unconfirmed(new_sponsor);801 Self::save_collection(target_collection);802803 Ok(())804 }805806 /// # Permissions807 /// 808 /// * Sponsor.809 /// 810 /// # Arguments811 /// 812 /// * collection_id.813 #[weight = <T as Config>::WeightInfo::confirm_sponsorship()]814 #[transactional]815 pub fn confirm_sponsorship(origin, collection_id: CollectionId) -> DispatchResult {816 let sender = ensure_signed(origin)?;817818 let mut target_collection = Self::get_collection(collection_id)?;819 ensure!(820 target_collection.sponsorship.pending_sponsor() == Some(&sender),821 Error::<T>::ConfirmUnsetSponsorFail822 );823824 target_collection.sponsorship = SponsorshipState::Confirmed(sender);825 Self::save_collection(target_collection);826827 Ok(())828 }829830 /// Switch back to pay-per-own-transaction model.831 ///832 /// # Permissions833 ///834 /// * Collection owner.835 /// 836 /// # Arguments837 /// 838 /// * collection_id.839 #[weight = <T as Config>::WeightInfo::remove_collection_sponsor()]840 #[transactional]841 pub fn remove_collection_sponsor(origin, collection_id: CollectionId) -> DispatchResult {842 let sender = ensure_signed(origin)?;843844 let mut target_collection = Self::get_collection(collection_id)?;845 Self::check_owner_permissions(&target_collection, &sender)?;846847 target_collection.sponsorship = SponsorshipState::Disabled;848 Self::save_collection(target_collection);849850 Ok(())851 }852853 /// This method creates a concrete instance of NFT Collection created with CreateCollection method.854 /// 855 /// # Permissions856 /// 857 /// * Collection Owner.858 /// * Collection Admin.859 /// * Anyone if860 /// * White List is enabled, and861 /// * Address is added to white list, and862 /// * MintPermission is enabled (see SetMintPermission method)863 /// 864 /// # Arguments865 /// 866 /// * collection_id: ID of the collection.867 /// 868 /// * owner: Address, initial owner of the NFT.869 ///870 /// * data: Token data to store on chain.871 // #[weight =872 // (130_000_000 as Weight)873 // .saturating_add((2135 as Weight).saturating_mul((properties.len() as u64) as Weight))874 // .saturating_add(RocksDbWeight::get().reads(10 as Weight))875 // .saturating_add(RocksDbWeight::get().writes(8 as Weight))]876877 #[weight = <T as Config>::WeightInfo::create_item(data.len())]878 #[transactional]879 pub fn create_item(origin, collection_id: CollectionId, owner: T::CrossAccountId, data: CreateItemData) -> DispatchResult {880 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);881 let collection = Self::get_collection(collection_id)?;882883 Self::create_item_internal(&sender, &collection, &owner, data)?;884885 Self::submit_logs(collection)?;886 Ok(())887 }888889 /// This method creates multiple items in a collection created with CreateCollection method.890 /// 891 /// # Permissions892 /// 893 /// * Collection Owner.894 /// * Collection Admin.895 /// * Anyone if896 /// * White List is enabled, and897 /// * Address is added to white list, and898 /// * MintPermission is enabled (see SetMintPermission method)899 /// 900 /// # Arguments901 /// 902 /// * collection_id: ID of the collection.903 /// 904 /// * itemsData: Array items properties. Each property is an array of bytes itself, see [create_item].905 /// 906 /// * owner: Address, initial owner of the NFT.907 #[weight = <T as Config>::WeightInfo::create_item(items_data.into_iter()908 .map(|data| { data.len() })909 .sum())]910 #[transactional]911 pub fn create_multiple_items(origin, collection_id: CollectionId, owner: T::CrossAccountId, items_data: Vec<CreateItemData>) -> DispatchResult {912913 ensure!(items_data.len() > 0, Error::<T>::EmptyArgument);914 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);915 let collection = Self::get_collection(collection_id)?;916917 Self::create_multiple_items_internal(&sender, &collection, &owner, items_data)?;918919 Self::submit_logs(collection)?;920 Ok(())921 }922923 /// Destroys a concrete instance of NFT.924 /// 925 /// # Permissions926 /// 927 /// * Collection Owner.928 /// * Collection Admin.929 /// * Current NFT Owner.930 /// 931 /// # Arguments932 /// 933 /// * collection_id: ID of the collection.934 /// 935 /// * item_id: ID of NFT to burn.936 #[weight = <T as Config>::WeightInfo::burn_item()]937 #[transactional]938 pub fn burn_item(origin, collection_id: CollectionId, item_id: TokenId, value: u128) -> DispatchResult {939940 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);941 let target_collection = Self::get_collection(collection_id)?;942943 Self::burn_item_internal(&sender, &target_collection, item_id, value)?;944945 Self::submit_logs(target_collection)?;946 Ok(())947 }948949 /// Change ownership of the token.950 /// 951 /// # Permissions952 /// 953 /// * Collection Owner954 /// * Collection Admin955 /// * Current NFT owner956 ///957 /// # Arguments958 /// 959 /// * recipient: Address of token recipient.960 /// 961 /// * collection_id.962 /// 963 /// * item_id: ID of the item964 /// * Non-Fungible Mode: Required.965 /// * Fungible Mode: Ignored.966 /// * Re-Fungible Mode: Required.967 /// 968 /// * value: Amount to transfer.969 /// * Non-Fungible Mode: Ignored970 /// * Fungible Mode: Must specify transferred amount971 /// * Re-Fungible Mode: Must specify transferred portion (between 0 and 1)972 #[weight = <T as Config>::WeightInfo::transfer()]973 #[transactional]974 pub fn transfer(origin, recipient: T::CrossAccountId, collection_id: CollectionId, item_id: TokenId, value: u128) -> DispatchResult {975 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);976 let collection = Self::get_collection(collection_id)?;977978 Self::transfer_internal(&sender, &recipient, &collection, item_id, value)?;979980 Self::submit_logs(collection)?;981 Ok(())982 }983984 /// Set, change, or remove approved address to transfer the ownership of the NFT.985 /// 986 /// # Permissions987 /// 988 /// * Collection Owner989 /// * Collection Admin990 /// * Current NFT owner991 /// 992 /// # Arguments993 /// 994 /// * approved: Address that is approved to transfer this NFT or zero (if needed to remove approval).995 /// 996 /// * collection_id.997 /// 998 /// * item_id: ID of the item.999 #[weight = <T as Config>::WeightInfo::approve()]1000 #[transactional]1001 pub fn approve(origin, spender: T::CrossAccountId, collection_id: CollectionId, item_id: TokenId, amount: u128) -> DispatchResult {1002 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1003 let collection = Self::get_collection(collection_id)?;10041005 Self::approve_internal(&sender, &spender, &collection, item_id, amount)?;10061007 Self::submit_logs(collection)?;1008 Ok(())1009 }1010 1011 /// Change ownership of a NFT on behalf of the owner. See Approve method for additional information. After this method executes, the approval is removed so that the approved address will not be able to transfer this NFT again from this owner.1012 /// 1013 /// # Permissions1014 /// * Collection Owner1015 /// * Collection Admin1016 /// * Current NFT owner1017 /// * Address approved by current NFT owner1018 /// 1019 /// # Arguments1020 /// 1021 /// * from: Address that owns token.1022 /// 1023 /// * recipient: Address of token recipient.1024 /// 1025 /// * collection_id.1026 /// 1027 /// * item_id: ID of the item.1028 /// 1029 /// * value: Amount to transfer.1030 #[weight = <T as Config>::WeightInfo::transfer_from()]1031 #[transactional]1032 pub fn transfer_from(origin, from: T::CrossAccountId, recipient: T::CrossAccountId, collection_id: CollectionId, item_id: TokenId, value: u128 ) -> DispatchResult {1033 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1034 let collection = Self::get_collection(collection_id)?;10351036 Self::transfer_from_internal(&sender, &from, &recipient, &collection, item_id, value)?;10371038 Self::submit_logs(collection)?;1039 Ok(())1040 }1041 // #[weight = 0]1042 // // let no_perm_mes = "You do not have permissions to modify this collection";1043 // // ensure!(<ApprovedList<T>>::contains_key((collection_id, item_id)), no_perm_mes);1044 // // let list_itm = <ApprovedList<T>>::get((collection_id, item_id));1045 // // ensure!(list_itm.contains(&new_owner.clone()), no_perm_mes);10461047 // // // on_nft_received call10481049 // // Self::transfer(origin, collection_id, item_id, new_owner)?;10501051 // Ok(())1052 // }10531054 /// Set off-chain data schema.1055 /// 1056 /// # Permissions1057 /// 1058 /// * Collection Owner1059 /// * Collection Admin1060 /// 1061 /// # Arguments1062 /// 1063 /// * collection_id.1064 /// 1065 /// * schema: String representing the offchain data schema.1066 #[weight = <T as Config>::WeightInfo::set_variable_meta_data()]1067 #[transactional]1068 pub fn set_variable_meta_data (1069 origin,1070 collection_id: CollectionId,1071 item_id: TokenId,1072 data: Vec<u8>1073 ) -> DispatchResult {1074 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1075 1076 let collection = Self::get_collection(collection_id)?;10771078 Self::set_variable_meta_data_internal(&sender, &collection, item_id, data)?;10791080 Ok(())1081 }1082 1083 /// Set schema standard1084 /// ImageURL1085 /// Unique1086 /// 1087 /// # Permissions1088 /// 1089 /// * Collection Owner1090 /// * Collection Admin1091 /// 1092 /// # Arguments1093 /// 1094 /// * collection_id.1095 /// 1096 /// * schema: SchemaVersion: enum1097 #[weight = <T as Config>::WeightInfo::set_schema_version()]1098 #[transactional]1099 pub fn set_schema_version(1100 origin,1101 collection_id: CollectionId,1102 version: SchemaVersion1103 ) -> DispatchResult {1104 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1105 let mut target_collection = Self::get_collection(collection_id)?;1106 Self::check_owner_or_admin_permissions(&target_collection, &sender)?;1107 target_collection.schema_version = version;1108 Self::save_collection(target_collection);11091110 Ok(())1111 }11121113 /// Set off-chain data schema.1114 /// 1115 /// # Permissions1116 /// 1117 /// * Collection Owner1118 /// * Collection Admin1119 /// 1120 /// # Arguments1121 /// 1122 /// * collection_id.1123 /// 1124 /// * schema: String representing the offchain data schema.1125 #[weight = <T as Config>::WeightInfo::set_offchain_schema()]1126 #[transactional]1127 pub fn set_offchain_schema(1128 origin,1129 collection_id: CollectionId,1130 schema: Vec<u8>1131 ) -> DispatchResult {1132 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1133 let mut target_collection = Self::get_collection(collection_id)?;1134 Self::check_owner_or_admin_permissions(&target_collection, &sender)?;11351136 // check schema limit1137 ensure!(schema.len() as u32 <= ChainLimit::get().offchain_schema_limit, "");11381139 target_collection.offchain_schema = schema;1140 Self::save_collection(target_collection);11411142 Ok(())1143 }11441145 /// Set const on-chain data schema.1146 /// 1147 /// # Permissions1148 /// 1149 /// * Collection Owner1150 /// * Collection Admin1151 /// 1152 /// # Arguments1153 /// 1154 /// * collection_id.1155 /// 1156 /// * schema: String representing the const on-chain data schema.1157 #[weight = <T as Config>::WeightInfo::set_const_on_chain_schema()]1158 #[transactional]1159 pub fn set_const_on_chain_schema (1160 origin,1161 collection_id: CollectionId,1162 schema: Vec<u8>1163 ) -> DispatchResult {1164 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1165 let mut target_collection = Self::get_collection(collection_id)?;1166 Self::check_owner_or_admin_permissions(&target_collection, &sender)?;11671168 // check schema limit1169 ensure!(schema.len() as u32 <= ChainLimit::get().const_on_chain_schema_limit, "");11701171 target_collection.const_on_chain_schema = schema;1172 Self::save_collection(target_collection);11731174 Ok(())1175 }11761177 /// Set variable on-chain data schema.1178 /// 1179 /// # Permissions1180 /// 1181 /// * Collection Owner1182 /// * Collection Admin1183 /// 1184 /// # Arguments1185 /// 1186 /// * collection_id.1187 /// 1188 /// * schema: String representing the variable on-chain data schema.1189 #[weight = <T as Config>::WeightInfo::set_const_on_chain_schema()]1190 #[transactional]1191 pub fn set_variable_on_chain_schema (1192 origin,1193 collection_id: CollectionId,1194 schema: Vec<u8>1195 ) -> DispatchResult {1196 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1197 let mut target_collection = Self::get_collection(collection_id)?;1198 Self::check_owner_or_admin_permissions(&target_collection, &sender)?;11991200 // check schema limit1201 ensure!(schema.len() as u32 <= ChainLimit::get().variable_on_chain_schema_limit, "");12021203 target_collection.variable_on_chain_schema = schema;1204 Self::save_collection(target_collection);12051206 Ok(())1207 }12081209 // Sudo permissions function1210 #[weight = <T as Config>::WeightInfo::set_chain_limits()]1211 #[transactional]1212 pub fn set_chain_limits(1213 origin,1214 limits: ChainLimits1215 ) -> DispatchResult {12161217 #[cfg(not(feature = "runtime-benchmarks"))]1218 ensure_root(origin)?;12191220 <ChainLimit>::put(limits);1221 Ok(())1222 }12231224 #[weight = <T as Config>::WeightInfo::set_collection_limits()]1225 #[transactional]1226 pub fn set_collection_limits(1227 origin,1228 collection_id: u32,1229 new_limits: CollectionLimits<T::BlockNumber>,1230 ) -> DispatchResult {1231 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1232 let mut target_collection = Self::get_collection(collection_id)?;1233 Self::check_owner_permissions(&target_collection, &sender.as_sub())?;1234 let old_limits = &target_collection.limits;1235 let chain_limits = ChainLimit::get();12361237 // collection bounds1238 ensure!(new_limits.sponsor_transfer_timeout <= MAX_SPONSOR_TIMEOUT &&1239 new_limits.account_token_ownership_limit <= MAX_TOKEN_OWNERSHIP && 1240 new_limits.sponsored_data_size <= chain_limits.custom_data_limit,1241 Error::<T>::CollectionLimitBoundsExceeded);12421243 // token_limit check prev1244 ensure!(old_limits.token_limit >= new_limits.token_limit, Error::<T>::CollectionTokenLimitExceeded);1245 ensure!(new_limits.token_limit > 0, Error::<T>::CollectionTokenLimitExceeded);12461247 ensure!(1248 (old_limits.owner_can_transfer || !new_limits.owner_can_transfer) &&1249 (old_limits.owner_can_destroy || !new_limits.owner_can_destroy),1250 Error::<T>::OwnerPermissionsCantBeReverted,1251 );12521253 target_collection.limits = new_limits;1254 Self::save_collection(target_collection);12551256 Ok(())1257 } 1258 }1259}12601261impl<T: Config> Module<T> {1262 pub fn create_item_internal(sender: &T::CrossAccountId, collection: &CollectionHandle<T>, owner: &T::CrossAccountId, data: CreateItemData) -> DispatchResult {1263 Self::can_create_items_in_collection(&collection, &sender, &owner, 1)?;1264 Self::validate_create_item_args(&collection, &data)?;1265 Self::create_item_no_validation(&collection, owner, data)?;12661267 Ok(())1268 }12691270 pub fn transfer_internal(sender: &T::CrossAccountId, recipient: &T::CrossAccountId, target_collection: &CollectionHandle<T>, item_id: TokenId, value: u128) -> DispatchResult {1271 target_collection.consume_gas(2000000)?;1272 // Limits check1273 Self::is_correct_transfer(target_collection, &recipient)?;12741275 // Transfer permissions check1276 ensure!(Self::is_item_owner(&sender, target_collection, item_id) ||1277 Self::is_owner_or_admin_permissions(target_collection, &sender),1278 Error::<T>::NoPermission);12791280 if target_collection.access == AccessMode::WhiteList {1281 Self::check_white_list(target_collection, &sender)?;1282 Self::check_white_list(target_collection, &recipient)?;1283 }12841285 match target_collection.mode1286 {1287 CollectionMode::NFT => Self::transfer_nft(target_collection, item_id, sender.clone(), recipient.clone())?,1288 CollectionMode::Fungible(_) => Self::transfer_fungible(target_collection, value, &sender, &recipient)?,1289 CollectionMode::ReFungible => Self::transfer_refungible(target_collection, item_id, value, sender.clone(), recipient.clone())?,1290 _ => ()1291 };12921293 Self::deposit_event(RawEvent::Transfer(target_collection.id, item_id, sender.clone(), recipient.clone(), value));12941295 Ok(())1296 }12971298 pub fn approve_internal(1299 sender: &T::CrossAccountId,1300 spender: &T::CrossAccountId,1301 collection: &CollectionHandle<T>,1302 item_id: TokenId,1303 amount: u1281304 ) -> DispatchResult {1305 collection.consume_gas(2000000)?;1306 Self::token_exists(&collection, item_id)?;13071308 // Transfer permissions check1309 let bypasses_limits = collection.limits.owner_can_transfer &&1310 Self::is_owner_or_admin_permissions(1311 &collection,1312 &sender,1313 );13141315 let allowance_limit = if bypasses_limits {1316 None1317 } else if let Some(amount) = Self::owned_amount(1318 &sender,1319 &collection,1320 item_id,1321 ) {1322 Some(amount)1323 } else {1324 fail!(Error::<T>::NoPermission);1325 };13261327 if collection.access == AccessMode::WhiteList {1328 Self::check_white_list(&collection, &sender)?;1329 Self::check_white_list(&collection, &spender)?;1330 }13311332 let allowance: u128 = amount1333 .checked_add(<Allowances<T>>::get(collection.id, (item_id, sender.as_sub(), spender.as_sub())))1334 .ok_or(Error::<T>::NumOverflow)?;1335 if let Some(limit) = allowance_limit {1336 ensure!(limit >= allowance, Error::<T>::TokenValueTooLow);1337 }1338 <Allowances<T>>::insert(collection.id, (item_id, sender.as_sub(), spender.as_sub()), allowance);13391340 if matches!(collection.mode, CollectionMode::NFT) {1341 // TODO: NFT: only one owner may exist for token in ERC7211342 collection.log(ERC721Events::Approval {1343 owner: *sender.as_eth(),1344 approved: *spender.as_eth(),1345 token_id: item_id.into(),1346 });1347 }13481349 if matches!(collection.mode, CollectionMode::Fungible(_)) {1350 // TODO: NFT: only one owner may exist for token in ERC201351 collection.log(ERC20Events::Approval {1352 owner: *sender.as_eth(),1353 spender: *spender.as_eth(),1354 value: allowance.into()1355 });1356 }13571358 Self::deposit_event(RawEvent::Approved(collection.id, item_id, sender.clone(), spender.clone(), allowance));1359 Ok(())1360 }13611362 pub fn transfer_from_internal(1363 sender: &T::CrossAccountId,1364 from: &T::CrossAccountId,1365 recipient: &T::CrossAccountId,1366 collection: &CollectionHandle<T>,1367 item_id: TokenId,1368 amount: u128,1369 ) -> DispatchResult {1370 collection.consume_gas(2000000)?;1371 // Check approval1372 let approval: u128 = <Allowances<T>>::get(collection.id, (item_id, from.as_sub(), sender.as_sub()));13731374 // Limits check1375 Self::is_correct_transfer(&collection, &recipient)?;13761377 // Transfer permissions check1378 ensure!(1379 approval >= amount || 1380 (1381 collection.limits.owner_can_transfer &&1382 Self::is_owner_or_admin_permissions(&collection, &sender)1383 ),1384 Error::<T>::NoPermission1385 );13861387 if collection.access == AccessMode::WhiteList {1388 Self::check_white_list(&collection, &sender)?;1389 Self::check_white_list(&collection, &recipient)?;1390 }13911392 // Reduce approval by transferred amount or remove if remaining approval drops to 01393 let allowance = approval.saturating_sub(amount);1394 if allowance > 0 {1395 <Allowances<T>>::insert(collection.id, (item_id, from.as_sub(), sender.as_sub()), allowance);1396 } else {1397 <Allowances<T>>::remove(collection.id, (item_id, from.as_sub(), sender.as_sub()));1398 }13991400 match collection.mode {1401 CollectionMode::NFT => {1402 Self::transfer_nft(&collection, item_id, from.clone(), recipient.clone())?1403 }1404 CollectionMode::Fungible(_) => {1405 Self::transfer_fungible(&collection, amount, &from, &recipient)?1406 }1407 CollectionMode::ReFungible => {1408 Self::transfer_refungible(&collection, item_id, amount, from.clone(), recipient.clone())?1409 }1410 _ => ()1411 };14121413 if matches!(collection.mode, CollectionMode::Fungible(_)) {1414 collection.log(ERC20Events::Approval {1415 owner: *from.as_eth(),1416 spender: *sender.as_eth(),1417 value: allowance.into()1418 });1419 }14201421 Ok(())1422 }14231424 pub fn set_variable_meta_data_internal(1425 sender: &T::CrossAccountId,1426 collection: &CollectionHandle<T>, 1427 item_id: TokenId,1428 data: Vec<u8>,1429 ) -> DispatchResult {1430 Self::token_exists(&collection, item_id)?;14311432 ensure!(ChainLimit::get().custom_data_limit >= data.len() as u32, Error::<T>::TokenVariableDataLimitExceeded);14331434 // Modify permissions check1435 ensure!(Self::is_item_owner(&sender, &collection, item_id) ||1436 Self::is_owner_or_admin_permissions(&collection, &sender),1437 Error::<T>::NoPermission);14381439 match collection.mode1440 {1441 CollectionMode::NFT => Self::set_nft_variable_data(&collection, item_id, data)?,1442 CollectionMode::ReFungible => Self::set_re_fungible_variable_data(&collection, item_id, data)?,1443 CollectionMode::Fungible(_) => fail!(Error::<T>::CantStoreMetadataInFungibleTokens),1444 _ => fail!(Error::<T>::UnexpectedCollectionType)1445 };14461447 Ok(())1448 }14491450 pub fn create_multiple_items_internal(1451 sender: &T::CrossAccountId,1452 collection: &CollectionHandle<T>,1453 owner: &T::CrossAccountId,1454 items_data: Vec<CreateItemData>,1455 ) -> DispatchResult {1456 Self::can_create_items_in_collection(&collection, &sender, &owner, items_data.len() as u32)?;14571458 for data in &items_data {1459 Self::validate_create_item_args(&collection, data)?;1460 }1461 for data in &items_data {1462 Self::create_item_no_validation(&collection, owner, data.clone())?;1463 }14641465 Ok(())1466 }14671468 pub fn burn_item_internal(1469 sender: &T::CrossAccountId,1470 collection: &CollectionHandle<T>,1471 item_id: TokenId,1472 value: u128,1473 ) -> DispatchResult {1474 ensure!(1475 Self::is_item_owner(&sender, &collection, item_id) ||1476 (1477 collection.limits.owner_can_transfer &&1478 Self::is_owner_or_admin_permissions(&collection, &sender)1479 ),1480 Error::<T>::NoPermission1481 );14821483 if collection.access == AccessMode::WhiteList {1484 Self::check_white_list(&collection, &sender)?;1485 }14861487 match collection.mode1488 {1489 CollectionMode::NFT => Self::burn_nft_item(&collection, item_id)?,1490 CollectionMode::Fungible(_) => Self::burn_fungible_item(&sender, &collection, value)?,1491 CollectionMode::ReFungible => Self::burn_refungible_item(&collection, item_id, &sender)?,1492 _ => ()1493 };14941495 Ok(())1496 }14971498 pub fn toggle_white_list_internal(1499 sender: &T::CrossAccountId,1500 collection: &CollectionHandle<T>,1501 address: &T::CrossAccountId,1502 whitelisted: bool,1503 ) -> DispatchResult {1504 Self::check_owner_or_admin_permissions(&collection, &sender)?;15051506 if whitelisted {1507 <WhiteList<T>>::insert(collection.id, address.as_sub(), true);1508 } else {1509 <WhiteList<T>>::remove(collection.id, address.as_sub());1510 }15111512 Ok(())1513 }15141515 fn is_correct_transfer(collection: &CollectionHandle<T>, recipient: &T::CrossAccountId) -> DispatchResult {1516 let collection_id = collection.id;15171518 // check token limit and account token limit1519 let account_items: u32 = <AddressTokens<T>>::get(collection_id, recipient.as_sub()).len() as u32;1520 ensure!(collection.limits.account_token_ownership_limit > account_items, Error::<T>::AccountTokenLimitExceeded);1521 1522 Ok(())1523 }15241525 fn can_create_items_in_collection(collection: &CollectionHandle<T>, sender: &T::CrossAccountId, owner: &T::CrossAccountId, amount: u32) -> DispatchResult {1526 let collection_id = collection.id;15271528 // check token limit and account token limit1529 let total_items: u32 = ItemListIndex::get(collection_id)1530 .checked_add(amount)1531 .ok_or(Error::<T>::CollectionTokenLimitExceeded)?;1532 let account_items: u32 = (<AddressTokens<T>>::get(collection_id, owner.as_sub()).len() as u32)1533 .checked_add(amount)1534 .ok_or(Error::<T>::AccountTokenLimitExceeded)?;1535 ensure!(collection.limits.token_limit >= total_items, Error::<T>::CollectionTokenLimitExceeded);1536 ensure!(collection.limits.account_token_ownership_limit >= account_items, Error::<T>::AccountTokenLimitExceeded);15371538 if !Self::is_owner_or_admin_permissions(collection, &sender) {1539 ensure!(collection.mint_mode == true, Error::<T>::PublicMintingNotAllowed);1540 Self::check_white_list(collection, owner)?;1541 Self::check_white_list(collection, sender)?;1542 }15431544 Ok(())1545 }15461547 fn validate_create_item_args(target_collection: &CollectionHandle<T>, data: &CreateItemData) -> DispatchResult {1548 match target_collection.mode1549 {1550 CollectionMode::NFT => {1551 if let CreateItemData::NFT(data) = data {1552 // check sizes1553 ensure!(ChainLimit::get().custom_data_limit >= data.const_data.len() as u32, Error::<T>::TokenConstDataLimitExceeded);1554 ensure!(ChainLimit::get().custom_data_limit >= data.variable_data.len() as u32, Error::<T>::TokenVariableDataLimitExceeded);1555 } else {1556 fail!(Error::<T>::NotNftDataUsedToMintNftCollectionToken);1557 }1558 },1559 CollectionMode::Fungible(_) => {1560 if let CreateItemData::Fungible(_) = data {1561 } else {1562 fail!(Error::<T>::NotFungibleDataUsedToMintFungibleCollectionToken);1563 }1564 },1565 CollectionMode::ReFungible => {1566 if let CreateItemData::ReFungible(data) = data {15671568 // check sizes1569 ensure!(ChainLimit::get().custom_data_limit >= data.const_data.len() as u32, Error::<T>::TokenConstDataLimitExceeded);1570 ensure!(ChainLimit::get().custom_data_limit >= data.variable_data.len() as u32, Error::<T>::TokenVariableDataLimitExceeded);15711572 // Check refungibility limits1573 ensure!(data.pieces <= MAX_REFUNGIBLE_PIECES, Error::<T>::WrongRefungiblePieces);1574 ensure!(data.pieces > 0, Error::<T>::WrongRefungiblePieces);1575 } else {1576 fail!(Error::<T>::NotReFungibleDataUsedToMintReFungibleCollectionToken);1577 }1578 },1579 _ => { fail!(Error::<T>::UnexpectedCollectionType); }1580 };15811582 Ok(())1583 }15841585 fn create_item_no_validation(collection: &CollectionHandle<T>, owner: &T::CrossAccountId, data: CreateItemData) -> DispatchResult {1586 match data1587 {1588 CreateItemData::NFT(data) => {1589 let item = NftItemType {1590 owner: owner.clone(),1591 const_data: data.const_data,1592 variable_data: data.variable_data1593 };15941595 Self::add_nft_item(collection, item)?;1596 },1597 CreateItemData::Fungible(data) => {1598 Self::add_fungible_item(collection, &owner, data.value)?;1599 },1600 CreateItemData::ReFungible(data) => {1601 let mut owner_list = Vec::new();1602 owner_list.push(Ownership {owner: owner.clone(), fraction: data.pieces});16031604 let item = ReFungibleItemType {1605 owner: owner_list,1606 const_data: data.const_data,1607 variable_data: data.variable_data1608 };16091610 Self::add_refungible_item(collection, item)?;1611 }1612 };16131614 Ok(())1615 }16161617 fn add_fungible_item(collection: &CollectionHandle<T>, owner: &T::CrossAccountId, value: u128) -> DispatchResult {1618 let collection_id = collection.id;16191620 // Does new owner already have an account?1621 let balance: u128 = <FungibleItemList<T>>::get(collection_id, owner.as_sub()).value;16221623 // Mint 1624 let item = FungibleItemType {1625 value: balance.checked_add(value).ok_or(Error::<T>::NumOverflow)?,1626 };1627 <FungibleItemList<T>>::insert(collection_id, owner.as_sub(), item);16281629 // Update balance1630 let new_balance = <Balance<T>>::get(collection_id, owner.as_sub())1631 .checked_add(value)1632 .ok_or(Error::<T>::NumOverflow)?;1633 <Balance<T>>::insert(collection_id, owner.as_sub(), new_balance);16341635 Self::deposit_event(RawEvent::ItemCreated(collection_id, 0, owner.clone()));1636 Ok(())1637 }16381639 fn add_refungible_item(collection: &CollectionHandle<T>, item: ReFungibleItemType<T::CrossAccountId>) -> DispatchResult {1640 let collection_id = collection.id;16411642 let current_index = <ItemListIndex>::get(collection_id)1643 .checked_add(1)1644 .ok_or(Error::<T>::NumOverflow)?;1645 let itemcopy = item.clone();16461647 ensure!(1648 item.owner.len() == 1,1649 Error::<T>::BadCreateRefungibleCall,1650 );1651 let item_owner = item.owner.first().expect("only one owner is defined");16521653 let value = item_owner.fraction;1654 let owner = item_owner.owner.clone();16551656 Self::add_token_index(collection_id, current_index, &owner)?;16571658 <ItemListIndex>::insert(collection_id, current_index);1659 <ReFungibleItemList<T>>::insert(collection_id, current_index, itemcopy);16601661 // Update balance1662 let new_balance = <Balance<T>>::get(collection_id, owner.as_sub())1663 .checked_add(value)1664 .ok_or(Error::<T>::NumOverflow)?;1665 <Balance<T>>::insert(collection_id, owner.as_sub(), new_balance);16661667 Self::deposit_event(RawEvent::ItemCreated(collection_id, current_index, owner));1668 Ok(())1669 }16701671 fn add_nft_item(collection: &CollectionHandle<T>, item: NftItemType<T::CrossAccountId>) -> DispatchResult {1672 let collection_id = collection.id;16731674 let current_index = <ItemListIndex>::get(collection_id)1675 .checked_add(1)1676 .ok_or(Error::<T>::NumOverflow)?;16771678 let item_owner = item.owner.clone();1679 Self::add_token_index(collection_id, current_index, &item.owner)?;16801681 <ItemListIndex>::insert(collection_id, current_index);1682 <NftItemList<T>>::insert(collection_id, current_index, item);16831684 // Update balance1685 let new_balance = <Balance<T>>::get(collection_id, item_owner.as_sub())1686 .checked_add(1)1687 .ok_or(Error::<T>::NumOverflow)?;1688 <Balance<T>>::insert(collection_id, item_owner.as_sub(), new_balance);16891690 collection.log(ERC721Events::Transfer {1691 from: H160::default(),1692 to: *item_owner.as_eth(),1693 token_id: current_index.into(),1694 });1695 Self::deposit_event(RawEvent::ItemCreated(collection_id, current_index, item_owner));1696 Ok(())1697 }16981699 fn burn_refungible_item(1700 collection: &CollectionHandle<T>,1701 item_id: TokenId,1702 owner: &T::CrossAccountId,1703 ) -> DispatchResult {1704 let collection_id = collection.id;17051706 let mut token = <ReFungibleItemList<T>>::get(collection_id, item_id)1707 .ok_or(Error::<T>::TokenNotFound)?;1708 let rft_balance = token1709 .owner1710 .iter()1711 .find(|&i| i.owner == *owner)1712 .ok_or(Error::<T>::TokenNotFound)?;1713 Self::remove_token_index(collection_id, item_id, owner)?;17141715 // update balance1716 let new_balance = <Balance<T>>::get(collection_id, rft_balance.owner.as_sub())1717 .checked_sub(rft_balance.fraction)1718 .ok_or(Error::<T>::NumOverflow)?;1719 <Balance<T>>::insert(collection_id, rft_balance.owner.as_sub(), new_balance);17201721 // Re-create owners list with sender removed1722 let index = token1723 .owner1724 .iter()1725 .position(|i| i.owner == *owner)1726 .expect("owned item is exists");1727 token.owner.remove(index);1728 let owner_count = token.owner.len();17291730 // Burn the token completely if this was the last (only) owner1731 if owner_count == 0 {1732 <ReFungibleItemList<T>>::remove(collection_id, item_id);1733 <VariableMetaDataBasket<T>>::remove(collection_id, item_id);1734 }1735 else {1736 <ReFungibleItemList<T>>::insert(collection_id, item_id, token);1737 }17381739 Ok(())1740 }17411742 fn burn_nft_item(collection: &CollectionHandle<T>, item_id: TokenId) -> DispatchResult {1743 let collection_id = collection.id;17441745 let item = <NftItemList<T>>::get(collection_id, item_id)1746 .ok_or(Error::<T>::TokenNotFound)?;1747 Self::remove_token_index(collection_id, item_id, &item.owner)?;17481749 // update balance1750 let new_balance = <Balance<T>>::get(collection_id, item.owner.as_sub())1751 .checked_sub(1)1752 .ok_or(Error::<T>::NumOverflow)?;1753 <Balance<T>>::insert(collection_id, item.owner.as_sub(), new_balance);1754 <NftItemList<T>>::remove(collection_id, item_id);1755 <VariableMetaDataBasket<T>>::remove(collection_id, item_id);17561757 Self::deposit_event(RawEvent::ItemDestroyed(collection.id, item_id));1758 Ok(())1759 }17601761 fn burn_fungible_item(owner: &T::CrossAccountId, collection: &CollectionHandle<T>, value: u128) -> DispatchResult {1762 let collection_id = collection.id;17631764 let mut balance = <FungibleItemList<T>>::get(collection_id, owner.as_sub());1765 ensure!(balance.value >= value, Error::<T>::TokenValueNotEnough);17661767 // update balance1768 let new_balance = <Balance<T>>::get(collection_id, owner.as_sub())1769 .checked_sub(value)1770 .ok_or(Error::<T>::NumOverflow)?;1771 <Balance<T>>::insert(collection_id, owner.as_sub(), new_balance);17721773 if balance.value - value > 0 {1774 balance.value -= value;1775 <FungibleItemList<T>>::insert(collection_id, owner.as_sub(), balance);1776 }1777 else {1778 <FungibleItemList<T>>::remove(collection_id, owner.as_sub());1779 }17801781 collection.log(ERC20Events::Transfer {1782 from: *owner.as_eth(),1783 to: H160::default(),1784 value: value.into(),1785 });1786 Ok(())1787 }17881789 pub fn get_collection(collection_id: CollectionId) -> Result<CollectionHandle<T>, sp_runtime::DispatchError> {1790 Ok(<CollectionHandle<T>>::get(collection_id)1791 .ok_or(Error::<T>::CollectionNotFound)?)1792 }17931794 fn save_collection(collection: CollectionHandle<T>) {1795 <CollectionById<T>>::insert(collection.id, collection.into_inner());1796 }17971798 pub fn submit_logs(collection: CollectionHandle<T>) -> DispatchResult {1799 if collection.logs.is_empty() {1800 return Ok(())1801 }1802 T::EthereumTransactionSender::submit_logs_transaction(1803 eth::generate_transaction(collection.id, T::EthereumChainId::get()),1804 collection.logs.retrieve_logs(),1805 )1806 }18071808 fn check_owner_permissions(target_collection: &CollectionHandle<T>, subject: &T::AccountId) -> DispatchResult {1809 ensure!(1810 *subject == target_collection.owner,1811 Error::<T>::NoPermission1812 );18131814 Ok(())1815 }18161817 fn is_owner_or_admin_permissions(collection: &CollectionHandle<T>, subject: &T::CrossAccountId) -> bool {1818 *subject.as_sub() == collection.owner || <AdminList<T>>::get(collection.id).contains(&subject)1819 }18201821 fn check_owner_or_admin_permissions(1822 collection: &CollectionHandle<T>,1823 subject: &T::CrossAccountId,1824 ) -> DispatchResult {1825 ensure!(Self::is_owner_or_admin_permissions(collection, subject), Error::<T>::NoPermission);18261827 Ok(())1828 }18291830 fn owned_amount(1831 subject: &T::CrossAccountId,1832 target_collection: &CollectionHandle<T>,1833 item_id: TokenId,1834 ) -> Option<u128> {1835 let collection_id = target_collection.id;18361837 match target_collection.mode {1838 CollectionMode::NFT => (<NftItemList<T>>::get(collection_id, item_id)?.owner == *subject)1839 .then(|| 1),1840 CollectionMode::Fungible(_) => Some(<FungibleItemList<T>>::get(collection_id, &subject.as_sub())1841 .value),1842 CollectionMode::ReFungible => <ReFungibleItemList<T>>::get(collection_id, item_id)?1843 .owner1844 .iter()1845 .find(|i| i.owner == *subject)1846 .map(|i| i.fraction),1847 CollectionMode::Invalid => None,1848 }1849 }18501851 fn is_item_owner(subject: &T::CrossAccountId, target_collection: &CollectionHandle<T>, item_id: TokenId) -> bool {1852 match target_collection.mode {1853 CollectionMode::Fungible(_) => true,1854 _ => Self::owned_amount(&subject, target_collection, item_id).is_some(),1855 }1856 }18571858 fn check_white_list(collection: &CollectionHandle<T>, address: &T::CrossAccountId) -> DispatchResult {1859 let collection_id = collection.id;18601861 let mes = Error::<T>::AddresNotInWhiteList;1862 ensure!(<WhiteList<T>>::contains_key(collection_id, address.as_sub()), mes);18631864 Ok(())1865 }18661867 /// Check if token exists. In case of Fungible, check if there is an entry for 1868 /// the owner in fungible balances double map1869 fn token_exists(1870 target_collection: &CollectionHandle<T>,1871 item_id: TokenId,1872 ) -> DispatchResult {1873 let collection_id = target_collection.id;1874 let exists = match target_collection.mode1875 {1876 CollectionMode::NFT => <NftItemList<T>>::contains_key(collection_id, item_id),1877 CollectionMode::Fungible(_) => true,1878 CollectionMode::ReFungible => <ReFungibleItemList<T>>::contains_key(collection_id, item_id),1879 _ => false1880 };18811882 ensure!(exists == true, Error::<T>::TokenNotFound);1883 Ok(())1884 }18851886 fn transfer_fungible(1887 collection: &CollectionHandle<T>,1888 value: u128,1889 owner: &T::CrossAccountId,1890 recipient: &T::CrossAccountId,1891 ) -> DispatchResult {1892 let collection_id = collection.id;18931894 let mut balance = <FungibleItemList<T>>::get(collection_id, owner.as_sub());1895 ensure!(balance.value >= value, Error::<T>::TokenValueTooLow);18961897 // Send balance to recipient (updates balanceOf of recipient)1898 Self::add_fungible_item(collection, recipient, value)?;18991900 // update balanceOf of sender1901 <Balance<T>>::insert(collection_id, owner.as_sub(), balance.value - value);19021903 // Reduce or remove sender1904 if balance.value == value {1905 <FungibleItemList<T>>::remove(collection_id, owner.as_sub());1906 }1907 else {1908 balance.value -= value;1909 <FungibleItemList<T>>::insert(collection_id, owner.as_sub(), balance);1910 }19111912 collection.log(ERC20Events::Transfer {1913 from: *owner.as_eth(),1914 to: *recipient.as_eth(),1915 value: value.into(),1916 });1917 Self::deposit_event(RawEvent::Transfer(collection.id, 1, owner.clone(), recipient.clone(), value));19181919 Ok(())1920 }19211922 fn transfer_refungible(1923 collection: &CollectionHandle<T>,1924 item_id: TokenId,1925 value: u128,1926 owner: T::CrossAccountId,1927 new_owner: T::CrossAccountId,1928 ) -> DispatchResult {1929 let collection_id = collection.id;1930 let full_item = <ReFungibleItemList<T>>::get(collection_id, item_id)1931 .ok_or(Error::<T>::TokenNotFound)?;19321933 let item = full_item1934 .owner1935 .iter()1936 .filter(|i| i.owner == owner)1937 .next()1938 .ok_or(Error::<T>::TokenNotFound)?;1939 let amount = item.fraction;19401941 ensure!(amount >= value, Error::<T>::TokenValueTooLow);19421943 // update balance1944 let balance_old_owner = <Balance<T>>::get(collection_id, item.owner.as_sub())1945 .checked_sub(value)1946 .ok_or(Error::<T>::NumOverflow)?;1947 <Balance<T>>::insert(collection_id, item.owner.as_sub(), balance_old_owner);19481949 let balance_new_owner = <Balance<T>>::get(collection_id, new_owner.as_sub())1950 .checked_add(value)1951 .ok_or(Error::<T>::NumOverflow)?;1952 <Balance<T>>::insert(collection_id, new_owner.as_sub(), balance_new_owner);19531954 let old_owner = item.owner.clone();1955 let new_owner_has_account = full_item.owner.iter().any(|i| i.owner == new_owner);19561957 // transfer1958 if amount == value && !new_owner_has_account {1959 // change owner1960 // new owner do not have account1961 let mut new_full_item = full_item.clone();1962 new_full_item1963 .owner1964 .iter_mut()1965 .find(|i| i.owner == owner)1966 .expect("old owner does present in refungible")1967 .owner = new_owner.clone();1968 <ReFungibleItemList<T>>::insert(collection_id, item_id, new_full_item);19691970 // update index collection1971 Self::move_token_index(collection_id, item_id, &old_owner, &new_owner)?;1972 } else {1973 let mut new_full_item = full_item.clone();1974 new_full_item1975 .owner1976 .iter_mut()1977 .find(|i| i.owner == owner)1978 .expect("old owner does present in refungible")1979 .fraction -= value;19801981 // separate amount1982 if new_owner_has_account {1983 // new owner has account1984 new_full_item1985 .owner1986 .iter_mut()1987 .find(|i| i.owner == new_owner)1988 .expect("new owner has account")1989 .fraction += value;1990 } else {1991 // new owner do not have account1992 new_full_item.owner.push(Ownership {1993 owner: new_owner.clone(),1994 fraction: value,1995 });1996 Self::add_token_index(collection_id, item_id, &new_owner)?;1997 }19981999 <ReFungibleItemList<T>>::insert(collection_id, item_id, new_full_item);2000 }20012002 Self::deposit_event(RawEvent::Transfer(collection.id, item_id, owner, new_owner, amount));20032004 Ok(())2005 }20062007 fn transfer_nft(2008 collection: &CollectionHandle<T>,2009 item_id: TokenId,2010 sender: T::CrossAccountId,2011 new_owner: T::CrossAccountId,2012 ) -> DispatchResult {2013 let collection_id = collection.id;2014 let mut item = <NftItemList<T>>::get(collection_id, item_id)2015 .ok_or(Error::<T>::TokenNotFound)?;20162017 ensure!(2018 sender == item.owner,2019 Error::<T>::MustBeTokenOwner2020 );20212022 // update balance2023 let balance_old_owner = <Balance<T>>::get(collection_id, item.owner.as_sub())2024 .checked_sub(1)2025 .ok_or(Error::<T>::NumOverflow)?;2026 <Balance<T>>::insert(collection_id, item.owner.as_sub(), balance_old_owner);20272028 let balance_new_owner = <Balance<T>>::get(collection_id, new_owner.as_sub())2029 .checked_add(1)2030 .ok_or(Error::<T>::NumOverflow)?;2031 <Balance<T>>::insert(collection_id, new_owner.as_sub(), balance_new_owner);20322033 // change owner2034 let old_owner = item.owner.clone();2035 item.owner = new_owner.clone();2036 <NftItemList<T>>::insert(collection_id, item_id, item);20372038 // update index collection2039 Self::move_token_index(collection_id, item_id, &old_owner, &new_owner)?;20402041 collection.log(ERC721Events::Transfer {2042 from: *sender.as_eth(),2043 to: *new_owner.as_eth(),2044 token_id: item_id.into(),2045 });2046 Self::deposit_event(RawEvent::Transfer(collection.id, item_id, sender, new_owner, 1));20472048 Ok(())2049 }2050 2051 fn set_re_fungible_variable_data(2052 collection: &CollectionHandle<T>,2053 item_id: TokenId,2054 data: Vec<u8>2055 ) -> DispatchResult {2056 let collection_id = collection.id;2057 let mut item = <ReFungibleItemList<T>>::get(collection_id, item_id)2058 .ok_or(Error::<T>::TokenNotFound)?;20592060 item.variable_data = data;20612062 <ReFungibleItemList<T>>::insert(collection_id, item_id, item);20632064 Ok(())2065 }20662067 fn set_nft_variable_data(2068 collection: &CollectionHandle<T>,2069 item_id: TokenId,2070 data: Vec<u8>2071 ) -> DispatchResult {2072 let collection_id = collection.id;2073 let mut item = <NftItemList<T>>::get(collection_id, item_id)2074 .ok_or(Error::<T>::TokenNotFound)?;2075 2076 item.variable_data = data;20772078 <NftItemList<T>>::insert(collection_id, item_id, item);2079 2080 Ok(())2081 }20822083 #[allow(dead_code)]2084 fn init_collection(item: &Collection<T>) {2085 // check params2086 assert!(2087 item.decimal_points <= MAX_DECIMAL_POINTS,2088 "decimal_points parameter must be lower than MAX_DECIMAL_POINTS"2089 );2090 assert!(2091 item.name.len() <= 64,2092 "Collection name can not be longer than 63 char"2093 );2094 assert!(2095 item.name.len() <= 256,2096 "Collection description can not be longer than 255 char"2097 );2098 assert!(2099 item.token_prefix.len() <= 16,2100 "Token prefix can not be longer than 15 char"2101 );21022103 // Generate next collection ID2104 let next_id = CreatedCollectionCount::get()2105 .checked_add(1)2106 .unwrap();21072108 CreatedCollectionCount::put(next_id);2109 }21102111 #[allow(dead_code)]2112 fn init_nft_token(collection_id: CollectionId, item: &NftItemType<T::CrossAccountId>) {2113 let current_index = <ItemListIndex>::get(collection_id)2114 .checked_add(1)2115 .unwrap();21162117 Self::add_token_index(collection_id, current_index, &item.owner).unwrap();21182119 <ItemListIndex>::insert(collection_id, current_index);21202121 // Update balance2122 let new_balance = <Balance<T>>::get(collection_id, item.owner.as_sub())2123 .checked_add(1)2124 .unwrap();2125 <Balance<T>>::insert(collection_id, item.owner.as_sub(), new_balance);2126 }21272128 #[allow(dead_code)]2129 fn init_fungible_token(collection_id: CollectionId, owner: &T::CrossAccountId, item: &FungibleItemType) {2130 let current_index = <ItemListIndex>::get(collection_id)2131 .checked_add(1)2132 .unwrap();21332134 Self::add_token_index(collection_id, current_index, owner).unwrap();21352136 <ItemListIndex>::insert(collection_id, current_index);21372138 // Update balance2139 let new_balance = <Balance<T>>::get(collection_id, owner.as_sub())2140 .checked_add(item.value)2141 .unwrap();2142 <Balance<T>>::insert(collection_id, owner.as_sub(), new_balance);2143 }21442145 #[allow(dead_code)]2146 fn init_refungible_token(collection_id: CollectionId, item: &ReFungibleItemType<T::CrossAccountId>) {2147 let current_index = <ItemListIndex>::get(collection_id)2148 .checked_add(1)2149 .unwrap();21502151 let value = item.owner.first().unwrap().fraction;2152 let owner = item.owner.first().unwrap().owner.clone();21532154 Self::add_token_index(collection_id, current_index, &owner).unwrap();21552156 <ItemListIndex>::insert(collection_id, current_index);21572158 // Update balance2159 let new_balance = <Balance<T>>::get(collection_id, &owner.as_sub())2160 .checked_add(value)2161 .unwrap();2162 <Balance<T>>::insert(collection_id, owner.as_sub(), new_balance);2163 }21642165 fn add_token_index(collection_id: CollectionId, item_index: TokenId, owner: &T::CrossAccountId) -> DispatchResult {2166 // add to account limit2167 if <AccountItemCount<T>>::contains_key(owner.as_sub()) {21682169 // bound Owned tokens by a single address2170 let count = <AccountItemCount<T>>::get(owner.as_sub());2171 ensure!(count < ChainLimit::get().account_token_ownership_limit, Error::<T>::AddressOwnershipLimitExceeded);21722173 <AccountItemCount<T>>::insert(owner.as_sub(), count2174 .checked_add(1)2175 .ok_or(Error::<T>::NumOverflow)?);2176 }2177 else {2178 <AccountItemCount<T>>::insert(owner.as_sub(), 1);2179 }21802181 let list_exists = <AddressTokens<T>>::contains_key(collection_id, owner.as_sub());2182 if list_exists {2183 let mut list = <AddressTokens<T>>::get(collection_id, owner.as_sub());2184 let item_contains = list.contains(&item_index.clone());21852186 if !item_contains {2187 list.push(item_index.clone());2188 }21892190 <AddressTokens<T>>::insert(collection_id, owner.as_sub(), list);2191 } else {2192 let mut itm = Vec::new();2193 itm.push(item_index.clone());2194 <AddressTokens<T>>::insert(collection_id, owner.as_sub(), itm);2195 }21962197 Ok(())2198 }21992200 fn remove_token_index(2201 collection_id: CollectionId,2202 item_index: TokenId,2203 owner: &T::CrossAccountId,2204 ) -> DispatchResult {22052206 // update counter2207 <AccountItemCount<T>>::insert(owner.as_sub(), 2208 <AccountItemCount<T>>::get(owner.as_sub())2209 .checked_sub(1)2210 .ok_or(Error::<T>::NumOverflow)?);221122122213 let list_exists = <AddressTokens<T>>::contains_key(collection_id, owner.as_sub());2214 if list_exists {2215 let mut list = <AddressTokens<T>>::get(collection_id, owner.as_sub());2216 let item_contains = list.contains(&item_index.clone());22172218 if item_contains {2219 list.retain(|&item| item != item_index);2220 <AddressTokens<T>>::insert(collection_id, owner.as_sub(), list);2221 }2222 }22232224 Ok(())2225 }22262227 fn move_token_index(2228 collection_id: CollectionId,2229 item_index: TokenId,2230 old_owner: &T::CrossAccountId,2231 new_owner: &T::CrossAccountId,2232 ) -> DispatchResult {2233 Self::remove_token_index(collection_id, item_index, old_owner)?;2234 Self::add_token_index(collection_id, item_index, new_owner)?;22352236 Ok(())2237 }2238 2239 fn ensure_contract_owned(account: T::AccountId, contract: &T::AccountId) -> DispatchResult {2240 ensure!(<ContractOwner<T>>::get(contract) == Some(account), Error::<T>::NoPermission);22412242 Ok(())2243 }2244}22452246sp_api::decl_runtime_apis! {2247 pub trait NftApi {2248 /// Used for ethereum integration2249 fn eth_contract_code(account: H160) -> Option<Vec<u8>>;2250 }2251}