difftreelog
feat log recording
in: master
2 files changed
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)]910#[cfg(feature = "std")]11pub use serde::*;1213use core::ops::{Deref, DerefMut};14use codec::{Decode, Encode};15pub use frame_support::{16 construct_runtime, decl_event, decl_module, decl_storage, decl_error,17 dispatch::DispatchResult,18 ensure, fail, parameter_types,19 traits::{20 Currency, ExistenceRequirement, Get, Imbalance, KeyOwnerProofSystem, OnUnbalanced,21 Randomness, IsSubType, WithdrawReasons,22 },23 weights::{24 constants::{BlockExecutionWeight, ExtrinsicBaseWeight, RocksDbWeight, WEIGHT_PER_SECOND},25 DispatchInfo, GetDispatchInfo, IdentityFee, Pays, PostDispatchInfo, Weight,26 WeightToFeePolynomial, DispatchClass,27 },28 StorageValue,29 transactional,30};3132use frame_system::{self as system, ensure_signed, ensure_root};33use sp_core::{H160, H256};34use sp_runtime::sp_std::prelude::Vec;35use sp_runtime::{36 traits::{37 Hash, DispatchInfoOf, Dispatchable, PostDispatchInfoOf, Saturating, SaturatedConversion, SignedExtension, Zero,38 },39 transaction_validity::{40 TransactionPriority, InvalidTransaction, TransactionValidity, TransactionValidityError, ValidTransaction,41 },42 FixedPointOperand, FixedU128,43};44use sp_runtime::traits::StaticLookup;45use pallet_contracts::chain_extension::UncheckedFrom;46use pallet_evm::AddressMapping;47use pallet_transaction_payment::OnChargeTransaction;4849#[cfg(test)]50mod mock;5152#[cfg(test)]53mod tests;5455mod default_weights;56mod eth;5758pub use eth::account::*;5960pub const MAX_DECIMAL_POINTS: DecimalPoints = 30;61pub const MAX_REFUNGIBLE_PIECES: u128 = 1_000_000_000_000_000_000_000;62pub const MAX_SPONSOR_TIMEOUT: u32 = 10_368_000;63pub const MAX_TOKEN_OWNERSHIP: u32 = 10_000_000;6465// Structs66// #region6768pub type CollectionId = u32;69pub type TokenId = u32;70pub type DecimalPoints = u8;7172#[derive(Encode, Decode, Eq, Debug, Clone, PartialEq)]73#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]74pub enum CollectionMode {75 Invalid,76 NFT,77 // decimal points78 Fungible(DecimalPoints),79 ReFungible,80}8182impl Default for CollectionMode {83 fn default() -> Self {84 Self::Invalid85 }86}8788impl Into<u8> for CollectionMode {89 fn into(self) -> u8 {90 match self {91 CollectionMode::Invalid => 0,92 CollectionMode::NFT => 1,93 CollectionMode::Fungible(_) => 2,94 CollectionMode::ReFungible => 3,95 }96 }97}9899#[derive(Encode, Decode, Eq, Debug, Clone, PartialEq)]100#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]101pub enum AccessMode {102 Normal,103 WhiteList,104}105impl Default for AccessMode {106 fn default() -> Self {107 Self::Normal108 }109}110111#[derive(Encode, Decode, Eq, Debug, Clone, PartialEq)]112#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]113pub enum SchemaVersion {114 ImageURL,115 Unique,116}117impl Default for SchemaVersion {118 fn default() -> Self {119 Self::ImageURL120 }121}122123#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]124#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]125pub struct Ownership<AccountId> {126 pub owner: AccountId,127 pub fraction: u128,128}129130#[derive(Encode, Decode, Debug, Clone, PartialEq)]131#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]132pub enum SponsorshipState<AccountId> {133 /// The fees are applied to the transaction sender134 Disabled,135 Unconfirmed(AccountId),136 /// Transactions are sponsored by specified account137 Confirmed(AccountId),138}139140impl<AccountId> SponsorshipState<AccountId> {141 fn sponsor(&self) -> Option<&AccountId> {142 match self {143 Self::Confirmed(sponsor) => Some(sponsor),144 _ => None,145 }146 }147148 fn pending_sponsor(&self) -> Option<&AccountId> {149 match self {150 Self::Unconfirmed(sponsor) | Self::Confirmed(sponsor) => Some(sponsor),151 _ => None,152 }153 }154155 fn confirmed(&self) -> bool {156 matches!(self, Self::Confirmed(_))157 }158}159160impl<T> Default for SponsorshipState<T> {161 fn default() -> Self {162 Self::Disabled163 }164}165166#[derive(Encode, Decode, Clone, PartialEq)]167#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]168pub struct Collection<T: Config> {169 pub owner: T::CrossAccountId,170 pub mode: CollectionMode,171 pub access: AccessMode,172 pub decimal_points: DecimalPoints,173 pub name: Vec<u16>, // 64 include null escape char174 pub description: Vec<u16>, // 256 include null escape char175 pub token_prefix: Vec<u8>, // 16 include null escape char176 pub mint_mode: bool,177 pub offchain_schema: Vec<u8>,178 pub schema_version: SchemaVersion,179 pub sponsorship: SponsorshipState<T::AccountId>,180 pub limits: CollectionLimits<T::BlockNumber>, // Collection private restrictions 181 pub variable_on_chain_schema: Vec<u8>, //182 pub const_on_chain_schema: Vec<u8>, //183}184185pub struct CollectionHandle<T: Config> {186 pub id: CollectionId,187 collection: Collection<T>,188}189190impl<T: Config> Deref for CollectionHandle<T> {191 type Target = Collection<T>;192193 fn deref(&self) -> &Self::Target {194 &self.collection195 }196}197198impl<T: Config> DerefMut for CollectionHandle<T> {199 fn deref_mut(&mut self) -> &mut Self::Target {200 &mut self.collection201 }202}203204#[derive(Encode, Decode, Debug, Clone, PartialEq)]205#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]206pub struct NftItemType<AccountId> {207 pub owner: AccountId,208 pub const_data: Vec<u8>,209 pub variable_data: Vec<u8>,210}211212#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]213#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]214pub struct FungibleItemType {215 pub value: u128,216}217218#[derive(Encode, Decode, Debug, Clone, PartialEq)]219#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]220pub struct ReFungibleItemType<AccountId> {221 pub owner: Vec<Ownership<AccountId>>,222 pub const_data: Vec<u8>,223 pub variable_data: Vec<u8>,224}225226// #[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]227// #[cfg_attr(feature = "std", derive(Serialize, Deserialize))]228// pub struct VestingItem<AccountId, Moment> {229// pub sender: AccountId,230// pub recipient: AccountId,231// pub collection_id: CollectionId,232// pub item_id: TokenId,233// pub amount: u64,234// pub vesting_date: Moment,235// }236237#[derive(Encode, Decode, Debug, Clone, PartialEq)]238#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]239pub struct CollectionLimits<BlockNumber: Encode + Decode> {240 pub account_token_ownership_limit: u32,241 pub sponsored_data_size: u32,242 /// None - setVariableMetadata is not sponsored243 /// Some(v) - setVariableMetadata is sponsored 244 /// if there is v block between txs245 pub sponsored_data_rate_limit: Option<BlockNumber>,246 pub token_limit: u32,247248 // Timeouts for item types in passed blocks249 pub sponsor_transfer_timeout: u32,250 pub owner_can_transfer: bool,251 pub owner_can_destroy: bool,252}253254impl<BlockNumber: Encode + Decode> Default for CollectionLimits<BlockNumber> {255 fn default() -> Self {256 Self { 257 account_token_ownership_limit: 10_000_000, 258 token_limit: u32::max_value(),259 sponsored_data_size: u32::MAX, 260 sponsored_data_rate_limit: None,261 sponsor_transfer_timeout: 14400,262 owner_can_transfer: true,263 owner_can_destroy: true264 }265 }266}267268#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]269#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]270pub struct ChainLimits {271 pub collection_numbers_limit: u32,272 pub account_token_ownership_limit: u32,273 pub collections_admins_limit: u64,274 pub custom_data_limit: u32,275276 // Timeouts for item types in passed blocks277 pub nft_sponsor_transfer_timeout: u32,278 pub fungible_sponsor_transfer_timeout: u32,279 pub refungible_sponsor_transfer_timeout: u32,280281 // Schema limits282 pub offchain_schema_limit: u32,283 pub variable_on_chain_schema_limit: u32,284 pub const_on_chain_schema_limit: u32,285}286287pub trait WeightInfo {288 fn create_collection() -> Weight;289 fn destroy_collection() -> Weight;290 fn add_to_white_list() -> Weight;291 fn remove_from_white_list() -> Weight;292 fn set_public_access_mode() -> Weight;293 fn set_mint_permission() -> Weight;294 fn change_collection_owner() -> Weight;295 fn add_collection_admin() -> Weight;296 fn remove_collection_admin() -> Weight;297 fn set_collection_sponsor() -> Weight;298 fn confirm_sponsorship() -> Weight;299 fn remove_collection_sponsor() -> Weight;300 fn create_item(s: usize) -> Weight;301 fn burn_item() -> Weight;302 fn transfer() -> Weight;303 fn approve() -> Weight;304 fn transfer_from() -> Weight;305 fn set_offchain_schema() -> Weight;306 fn set_const_on_chain_schema() -> Weight;307 fn set_variable_on_chain_schema() -> Weight;308 fn set_variable_meta_data() -> Weight;309 fn enable_contract_sponsoring() -> Weight;310 fn set_schema_version() -> Weight;311 fn set_chain_limits() -> Weight;312 fn set_contract_sponsoring_rate_limit() -> Weight;313 fn set_variable_meta_data_sponsoring_rate_limit() -> Weight;314 fn toggle_contract_white_list() -> Weight;315 fn add_to_contract_white_list() -> Weight;316 fn remove_from_contract_white_list() -> Weight;317 fn set_collection_limits() -> Weight;318}319320#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]321#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]322pub struct CreateNftData {323 pub const_data: Vec<u8>,324 pub variable_data: Vec<u8>,325}326327#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]328#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]329pub struct CreateFungibleData {330 pub value: u128,331}332333#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]334#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]335pub struct CreateReFungibleData {336 pub const_data: Vec<u8>,337 pub variable_data: Vec<u8>,338 pub pieces: u128,339}340341#[derive(Encode, Decode, Debug, Clone, PartialEq)]342#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]343pub enum CreateItemData {344 NFT(CreateNftData),345 Fungible(CreateFungibleData),346 ReFungible(CreateReFungibleData),347}348349impl CreateItemData {350 pub fn len(&self) -> usize {351 let len = match self {352 CreateItemData::NFT(data) => data.variable_data.len() + data.const_data.len(),353 CreateItemData::ReFungible(data) => data.variable_data.len() + data.const_data.len(),354 _ => 0355 };356 357 return len;358 }359}360361impl From<CreateNftData> for CreateItemData {362 fn from(item: CreateNftData) -> Self {363 CreateItemData::NFT(item)364 }365}366367impl From<CreateReFungibleData> for CreateItemData {368 fn from(item: CreateReFungibleData) -> Self {369 CreateItemData::ReFungible(item)370 }371}372373impl From<CreateFungibleData> for CreateItemData {374 fn from(item: CreateFungibleData) -> Self {375 CreateItemData::Fungible(item)376 }377}378379380decl_error! {381 /// Error for non-fungible-token module.382 pub enum Error for Module<T: Config> {383 /// Total collections bound exceeded.384 TotalCollectionsLimitExceeded,385 /// Decimal_points parameter must be lower than MAX_DECIMAL_POINTS constant, currently it is 30.386 CollectionDecimalPointLimitExceeded, 387 /// Collection name can not be longer than 63 char.388 CollectionNameLimitExceeded, 389 /// Collection description can not be longer than 255 char.390 CollectionDescriptionLimitExceeded, 391 /// Token prefix can not be longer than 15 char.392 CollectionTokenPrefixLimitExceeded,393 /// This collection does not exist.394 CollectionNotFound,395 /// Item not exists.396 TokenNotFound,397 /// Admin not found398 AdminNotFound,399 /// Arithmetic calculation overflow.400 NumOverflow, 401 /// Account already has admin role.402 AlreadyAdmin, 403 /// You do not own this collection.404 NoPermission,405 /// This address is not set as sponsor, use setCollectionSponsor first.406 ConfirmUnsetSponsorFail,407 /// Collection is not in mint mode.408 PublicMintingNotAllowed,409 /// Sender parameter and item owner must be equal.410 MustBeTokenOwner,411 /// Item balance not enough.412 TokenValueTooLow,413 /// Size of item is too large.414 NftSizeLimitExceeded,415 /// No approve found416 ApproveNotFound,417 /// Requested value more than approved.418 TokenValueNotEnough,419 /// Only approved addresses can call this method.420 ApproveRequired,421 /// Address is not in white list.422 AddresNotInWhiteList,423 /// Number of collection admins bound exceeded.424 CollectionAdminsLimitExceeded,425 /// Owned tokens by a single address bound exceeded.426 AddressOwnershipLimitExceeded,427 /// Length of items properties must be greater than 0.428 EmptyArgument,429 /// const_data exceeded data limit.430 TokenConstDataLimitExceeded,431 /// variable_data exceeded data limit.432 TokenVariableDataLimitExceeded,433 /// Not NFT item data used to mint in NFT collection.434 NotNftDataUsedToMintNftCollectionToken,435 /// Not Fungible item data used to mint in Fungible collection.436 NotFungibleDataUsedToMintFungibleCollectionToken,437 /// Not Re Fungible item data used to mint in Re Fungible collection.438 NotReFungibleDataUsedToMintReFungibleCollectionToken,439 /// Unexpected collection type.440 UnexpectedCollectionType,441 /// Can't store metadata in fungible tokens.442 CantStoreMetadataInFungibleTokens,443 /// Collection token limit exceeded444 CollectionTokenLimitExceeded,445 /// Account token limit exceeded per collection446 AccountTokenLimitExceeded,447 /// Collection limit bounds per collection exceeded448 CollectionLimitBoundsExceeded,449 /// Tried to enable permissions which are only permitted to be disabled450 OwnerPermissionsCantBeReverted,451 /// Schema data size limit bound exceeded452 SchemaDataLimitExceeded,453 /// Maximum refungibility exceeded454 WrongRefungiblePieces,455 /// createRefungible should be called with one owner456 BadCreateRefungibleCall,457 }458}459460pub trait Config: system::Config + Sized + pallet_transaction_payment::Config + pallet_contracts::Config {461 type Event: From<Event<Self>> + Into<<Self as system::Config>::Event>;462463 /// Weight information for extrinsics in this pallet.464 type WeightInfo: WeightInfo;465466 type EvmAddressMapping: pallet_evm::AddressMapping<Self::AccountId>;467 type EvmBackwardsAddressMapping: EvmBackwardsAddressMapping<Self::AccountId>;468 type EvmWithdrawOrigin: pallet_evm::EnsureAddressOrigin<Self::Origin, Success = Self::AccountId>;469470 type CrossAccountId: CrossAccountId<Self::AccountId>;471 type Currency: Currency<Self::AccountId>;472 type CollectionCreationPrice: Get<<<Self as Config>::Currency as Currency<Self::AccountId>>::Balance>;473 type TreasuryAccountId: Get<Self::AccountId>;474}475476#[cfg(feature = "runtime-benchmarks")]477mod benchmarking;478479// #endregion480481// # Used definitions482//483// ## User control levels484//485// chain-controlled - key is uncontrolled by user486// i.e autoincrementing index487// can use non-cryptographic hash488// real - key is controlled by user489// but it is hard to generate enough colliding values, i.e owner of signed txs490// can use non-cryptographic hash491// controlled - key is completly controlled by users492// i.e maps with mutable keys493// should use cryptographic hash494//495// ## User control level downgrade reasons496//497// ?1 - chain-controlled -> controlled498// collections/tokens can be destroyed, resulting in massive holes499// ?2 - chain-controlled -> controlled500// same as ?1, but can be only added, resulting in easier exploitation501// ?3 - real -> controlled502// no confirmation required, so addresses can be easily generated503decl_storage! {504 trait Store for Module<T: Config> as Nft {505506 //#region Private members507 /// Id of next collection508 CreatedCollectionCount: u32;509 /// Used for migrations510 ChainVersion: u64;511 /// Id of last collection token512 /// Collection id (controlled?1)513 ItemListIndex: map hasher(blake2_128_concat) CollectionId => TokenId;514 //#endregion515516 //#region Chain limits struct517 pub ChainLimit get(fn chain_limit) config(): ChainLimits;518 //#endregion519520 //#region Bound counters521 /// Amount of collections destroyed, used for total amount tracking with522 /// CreatedCollectionCount523 DestroyedCollectionCount: u32;524 /// Total amount of account owned tokens (NFTs + RFTs + unique fungibles)525 /// Account id (real)526 pub AccountItemCount get(fn account_item_count): map hasher(twox_64_concat) T::AccountId => u32;527 //#endregion528529 //#region Basic collections530 /// Collection info531 /// Collection id (controlled?1)532 pub CollectionById get(fn collection_id) config(): map hasher(blake2_128_concat) CollectionId => Option<Collection<T>> = None;533 /// List of collection admins534 /// Collection id (controlled?2)535 pub AdminList get(fn admin_list_collection): map hasher(blake2_128_concat) CollectionId => Vec<T::CrossAccountId>;536 /// Whitelisted collection users537 /// Collection id (controlled?2), user id (controlled?3)538 pub WhiteList get(fn white_list): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) T::AccountId => bool;539 //#endregion540541 /// How many of collection items user have542 /// Collection id (controlled?2), account id (real)543 pub Balance get(fn balance_count): double_map hasher(blake2_128_concat) CollectionId, hasher(twox_64_concat) T::AccountId => u128;544545 /// Amount of items which spender can transfer out of owners account (via transferFrom)546 /// Collection id (controlled?2), (token id (controlled ?2) + owner account id (real) + spender account id (controlled?3))547 /// TODO: Off chain worker should remove from this map when token gets removed548 pub Allowances get(fn approved): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) (TokenId, T::AccountId, T::AccountId) => u128;549550 //#region Item collections551 /// Collection id (controlled?2), token id (controlled?1)552 pub NftItemList get(fn nft_item_id) config(): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => Option<NftItemType<T::CrossAccountId>>;553 /// Collection id (controlled?2), owner (controlled?2)554 pub FungibleItemList get(fn fungible_item_id) config(): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) T::AccountId => FungibleItemType;555 /// Collection id (controlled?2), token id (controlled?1)556 pub ReFungibleItemList get(fn refungible_item_id) config(): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => Option<ReFungibleItemType<T::CrossAccountId>>;557 //#endregion558559 //#region Index list560 /// Collection id (controlled?2), tokens owner (controlled?2)561 pub AddressTokens get(fn address_tokens): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) T::AccountId => Vec<TokenId>;562 //#endregion563564 //#region Tokens transfer rate limit baskets565 /// (Collection id (controlled?2), who created (real))566 /// TODO: Off chain worker should remove from this map when collection gets removed567 pub CreateItemBasket get(fn create_item_basket): map hasher(blake2_128_concat) (CollectionId, T::AccountId) => T::BlockNumber;568 /// Collection id (controlled?2), token id (controlled?2)569 pub NftTransferBasket get(fn nft_transfer_basket): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => T::BlockNumber;570 /// Collection id (controlled?2), owning user (real)571 pub FungibleTransferBasket get(fn fungible_transfer_basket): double_map hasher(blake2_128_concat) CollectionId, hasher(twox_64_concat) T::AccountId => T::BlockNumber;572 /// Collection id (controlled?2), token id (controlled?2)573 pub ReFungibleTransferBasket get(fn refungible_transfer_basket): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => T::BlockNumber;574 //#endregion575576 /// Variable metadata sponsoring577 /// Collection id (controlled?2), token id (controlled?2)578 pub VariableMetaDataBasket get(fn variable_meta_data_basket): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => Option<T::BlockNumber> = None;579 580 //#region Contract Sponsorship and Ownership581 /// Contract address (real)582 pub ContractOwner get(fn contract_owner): map hasher(twox_64_concat) T::AccountId => Option<T::AccountId>;583 /// Contract address (real)584 pub ContractSelfSponsoring get(fn contract_self_sponsoring): map hasher(twox_64_concat) T::AccountId => bool;585 /// (Contract address(real), caller (real))586 pub ContractSponsorBasket get(fn contract_sponsor_basket): map hasher(twox_64_concat) (T::AccountId, T::AccountId) => T::BlockNumber;587 /// Contract address (real)588 pub ContractSponsoringRateLimit get(fn contract_sponsoring_rate_limit): map hasher(twox_64_concat) T::AccountId => T::BlockNumber;589 /// Contract address (real)590 pub ContractWhiteListEnabled get(fn contract_white_list_enabled): map hasher(twox_64_concat) T::AccountId => bool; 591 /// Contract address (real) => Whitelisted user (controlled?3)592 pub ContractWhiteList get(fn contract_white_list): double_map hasher(twox_64_concat) T::AccountId, hasher(blake2_128_concat) T::AccountId => bool; 593 //#endregion594 }595 add_extra_genesis {596 build(|config: &GenesisConfig<T>| {597 // Modification of storage598 for (_num, _c) in &config.collection_id {599 <Module<T>>::init_collection(_c);600 }601602 for (_num, _c, _i) in &config.nft_item_id {603 <Module<T>>::init_nft_token(*_c, _i);604 }605606 for (collection_id, account_id, fungible_item) in &config.fungible_item_id {607 <Module<T>>::init_fungible_token(*collection_id, &T::CrossAccountId::from_sub(account_id.clone()), fungible_item);608 }609610 for (_num, _c, _i) in &config.refungible_item_id {611 <Module<T>>::init_refungible_token(*_c, _i);612 }613 })614 }615}616617decl_event!(618 pub enum Event<T>619 where620 CrossAccountId = <T as Config>::CrossAccountId,621 {622 /// New collection was created623 /// 624 /// # Arguments625 /// 626 /// * collection_id: Globally unique identifier of newly created collection.627 /// 628 /// * mode: [CollectionMode] converted into u8.629 /// 630 /// * account_id: Collection owner.631 CollectionCreated(CollectionId, u8, CrossAccountId),632633 /// New item was created.634 /// 635 /// # Arguments636 /// 637 /// * collection_id: Id of the collection where item was created.638 /// 639 /// * item_id: Id of an item. Unique within the collection.640 ///641 /// * recipient: Owner of newly created item 642 ItemCreated(CollectionId, TokenId, CrossAccountId),643644 /// Collection item was burned.645 /// 646 /// # Arguments647 /// 648 /// collection_id.649 /// 650 /// item_id: Identifier of burned NFT.651 ItemDestroyed(CollectionId, TokenId),652653 /// Item was transferred654 ///655 /// * collection_id: Id of collection to which item is belong656 ///657 /// * item_id: Id of an item658 ///659 /// * sender: Original owner of item660 ///661 /// * recipient: New owner of item662 ///663 /// * amount: Always 1 for NFT664 Transfer(CollectionId, TokenId, CrossAccountId, CrossAccountId, u128),665666 /// * collection_id667 ///668 /// * item_id669 ///670 /// * sender671 ///672 /// * spender673 ///674 /// * amount675 Approved(CollectionId, TokenId, CrossAccountId, CrossAccountId, u128),676 }677);678679decl_module! {680 pub struct Module<T: Config> for enum Call 681 where 682 origin: T::Origin683 {684 fn deposit_event() = default;685 type Error = Error<T>;686687 fn on_initialize(now: T::BlockNumber) -> Weight {688 0689 }690691 /// 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.692 /// 693 /// # Permissions694 /// 695 /// * Anyone.696 /// 697 /// # Arguments698 /// 699 /// * collection_name: UTF-16 string with collection name (limit 64 characters), will be stored as zero-terminated.700 /// 701 /// * collection_description: UTF-16 string with collection description (limit 256 characters), will be stored as zero-terminated.702 /// 703 /// * token_prefix: UTF-8 string with token prefix.704 /// 705 /// * mode: [CollectionMode] collection type and type dependent data.706 // returns collection ID707 #[weight = <T as Config>::WeightInfo::create_collection()]708 #[transactional]709 pub fn create_collection(origin,710 collection_name: Vec<u16>,711 collection_description: Vec<u16>,712 token_prefix: Vec<u8>,713 mode: CollectionMode) -> DispatchResult {714715 // Anyone can create a collection716 let who = T::CrossAccountId::from_sub(ensure_signed(origin)?);717718 // Take a (non-refundable) deposit of collection creation719 let mut imbalance = <<<T as Config>::Currency as Currency<T::AccountId>>::PositiveImbalance>::zero();720 imbalance.subsume(<<T as Config>::Currency as Currency<T::AccountId>>::deposit_creating(721 &T::TreasuryAccountId::get(),722 T::CollectionCreationPrice::get(),723 ));724 <T as Config>::Currency::settle(725 who.as_sub(),726 imbalance,727 WithdrawReasons::TRANSFER,728 ExistenceRequirement::KeepAlive,729 ).map_err(|_| Error::<T>::NoPermission)?;730731 let decimal_points = match mode {732 CollectionMode::Fungible(points) => points,733 _ => 0734 };735736 let chain_limit = ChainLimit::get();737738 let created_count = CreatedCollectionCount::get();739 let destroyed_count = DestroyedCollectionCount::get();740741 // bound Total number of collections742 ensure!(created_count - destroyed_count < chain_limit.collection_numbers_limit, Error::<T>::TotalCollectionsLimitExceeded);743744 // check params745 ensure!(decimal_points <= MAX_DECIMAL_POINTS, Error::<T>::CollectionDecimalPointLimitExceeded);746 ensure!(collection_name.len() <= 64, Error::<T>::CollectionNameLimitExceeded);747 ensure!(collection_description.len() <= 256, Error::<T>::CollectionDescriptionLimitExceeded);748 ensure!(token_prefix.len() <= 16, Error::<T>::CollectionTokenPrefixLimitExceeded);749750 // Generate next collection ID751 let next_id = created_count752 .checked_add(1)753 .ok_or(Error::<T>::NumOverflow)?;754755 CreatedCollectionCount::put(next_id);756757 let limits = CollectionLimits {758 sponsored_data_size: chain_limit.custom_data_limit,759 ..Default::default()760 };761762 // Create new collection763 let new_collection = Collection {764 owner: who.clone(),765 name: collection_name,766 mode: mode.clone(),767 mint_mode: false,768 access: AccessMode::Normal,769 description: collection_description,770 decimal_points: decimal_points,771 token_prefix: token_prefix,772 offchain_schema: Vec::new(),773 schema_version: SchemaVersion::ImageURL,774 sponsorship: SponsorshipState::Disabled,775 variable_on_chain_schema: Vec::new(),776 const_on_chain_schema: Vec::new(),777 limits,778 };779780 // Add new collection to map781 <CollectionById<T>>::insert(next_id, new_collection);782783 // call event784 Self::deposit_event(RawEvent::CollectionCreated(next_id, mode.into(), who));785786 Ok(())787 }788789 /// **DANGEROUS**: Destroys collection and all NFTs within this collection. Users irrecoverably lose their assets and may lose real money.790 /// 791 /// # Permissions792 /// 793 /// * Collection Owner.794 /// 795 /// # Arguments796 /// 797 /// * collection_id: collection to destroy.798 #[weight = <T as Config>::WeightInfo::destroy_collection()]799 #[transactional]800 pub fn destroy_collection(origin, collection_id: CollectionId) -> DispatchResult {801802 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);803 let collection = Self::get_collection(collection_id)?;804 Self::check_owner_permissions(&collection, &sender)?;805 if !collection.limits.owner_can_destroy {806 fail!(Error::<T>::NoPermission);807 }808809 <AddressTokens<T>>::remove_prefix(collection_id);810 <Allowances<T>>::remove_prefix(collection_id);811 <Balance<T>>::remove_prefix(collection_id);812 <ItemListIndex>::remove(collection_id);813 <AdminList<T>>::remove(collection_id);814 <CollectionById<T>>::remove(collection_id);815 <WhiteList<T>>::remove_prefix(collection_id);816817 <NftItemList<T>>::remove_prefix(collection_id);818 <FungibleItemList<T>>::remove_prefix(collection_id);819 <ReFungibleItemList<T>>::remove_prefix(collection_id);820821 <NftTransferBasket<T>>::remove_prefix(collection_id);822 <FungibleTransferBasket<T>>::remove_prefix(collection_id);823 <ReFungibleTransferBasket<T>>::remove_prefix(collection_id);824825 <VariableMetaDataBasket<T>>::remove_prefix(collection_id);826827 DestroyedCollectionCount::put(DestroyedCollectionCount::get()828 .checked_add(1)829 .ok_or(Error::<T>::NumOverflow)?);830831 Ok(())832 }833834 /// Add an address to white list.835 /// 836 /// # Permissions837 /// 838 /// * Collection Owner839 /// * Collection Admin840 /// 841 /// # Arguments842 /// 843 /// * collection_id.844 /// 845 /// * address.846 #[weight = <T as Config>::WeightInfo::add_to_white_list()]847 #[transactional]848 pub fn add_to_white_list(origin, collection_id: CollectionId, address: T::CrossAccountId) -> DispatchResult{849850 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);851 let collection = Self::get_collection(collection_id)?;852 Self::check_owner_or_admin_permissions(&collection, &sender)?;853854 <WhiteList<T>>::insert(collection_id, address.as_sub(), true);855 856 Ok(())857 }858859 /// Remove an address from white list.860 /// 861 /// # Permissions862 /// 863 /// * Collection Owner864 /// * Collection Admin865 /// 866 /// # Arguments867 /// 868 /// * collection_id.869 /// 870 /// * address.871 #[weight = <T as Config>::WeightInfo::remove_from_white_list()]872 #[transactional]873 pub fn remove_from_white_list(origin, collection_id: CollectionId, address: T::CrossAccountId) -> DispatchResult{874875 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);876 let collection = Self::get_collection(collection_id)?;877 Self::check_owner_or_admin_permissions(&collection, &sender)?;878879 <WhiteList<T>>::remove(collection_id, address.as_sub());880881 Ok(())882 }883884 /// Toggle between normal and white list access for the methods with access for `Anyone`.885 /// 886 /// # Permissions887 /// 888 /// * Collection Owner.889 /// 890 /// # Arguments891 /// 892 /// * collection_id.893 /// 894 /// * mode: [AccessMode]895 #[weight = <T as Config>::WeightInfo::set_public_access_mode()]896 #[transactional]897 pub fn set_public_access_mode(origin, collection_id: CollectionId, mode: AccessMode) -> DispatchResult898 {899 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);900901 let mut target_collection = Self::get_collection(collection_id)?;902 Self::check_owner_permissions(&target_collection, &sender)?;903 target_collection.access = mode;904 Self::save_collection(target_collection);905906 Ok(())907 }908909 /// Allows Anyone to create tokens if:910 /// * White List is enabled, and911 /// * Address is added to white list, and912 /// * This method was called with True parameter913 /// 914 /// # Permissions915 /// * Collection Owner916 ///917 /// # Arguments918 /// 919 /// * collection_id.920 /// 921 /// * mint_permission: Boolean parameter. If True, allows minting to Anyone with conditions above.922 #[weight = <T as Config>::WeightInfo::set_mint_permission()]923 #[transactional]924 pub fn set_mint_permission(origin, collection_id: CollectionId, mint_permission: bool) -> DispatchResult925 {926 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);927928 let mut target_collection = Self::get_collection(collection_id)?;929 Self::check_owner_permissions(&target_collection, &sender)?;930 target_collection.mint_mode = mint_permission;931 Self::save_collection(target_collection);932933 Ok(())934 }935936 /// Change the owner of the collection.937 /// 938 /// # Permissions939 /// 940 /// * Collection Owner.941 /// 942 /// # Arguments943 /// 944 /// * collection_id.945 /// 946 /// * new_owner.947 #[weight = <T as Config>::WeightInfo::change_collection_owner()]948 #[transactional]949 pub fn change_collection_owner(origin, collection_id: CollectionId, new_owner: T::CrossAccountId) -> DispatchResult {950951 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);952 let mut target_collection = Self::get_collection(collection_id)?;953 Self::check_owner_permissions(&target_collection, &sender)?;954 target_collection.owner = new_owner;955 Self::save_collection(target_collection);956957 Ok(())958 }959960 /// Adds an admin of the Collection.961 /// 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. 962 /// 963 /// # Permissions964 /// 965 /// * Collection Owner.966 /// * Collection Admin.967 /// 968 /// # Arguments969 /// 970 /// * collection_id: ID of the Collection to add admin for.971 /// 972 /// * new_admin_id: Address of new admin to add.973 #[weight = <T as Config>::WeightInfo::add_collection_admin()]974 #[transactional]975 pub fn add_collection_admin(origin, collection_id: CollectionId, new_admin_id: T::CrossAccountId) -> DispatchResult {976 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);977 let collection = Self::get_collection(collection_id)?;978 Self::check_owner_or_admin_permissions(&collection, &sender)?;979 let mut admin_arr = <AdminList<T>>::get(collection_id);980981 match admin_arr.binary_search(&new_admin_id) {982 Ok(_) => {},983 Err(idx) => {984 let limits = ChainLimit::get();985 ensure!(admin_arr.len() < limits.collections_admins_limit as usize, Error::<T>::CollectionAdminsLimitExceeded);986 admin_arr.insert(idx, new_admin_id);987 <AdminList<T>>::insert(collection_id, admin_arr);988 }989 }990 Ok(())991 }992993 /// 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.994 ///995 /// # Permissions996 /// 997 /// * Collection Owner.998 /// * Collection Admin.999 /// 1000 /// # Arguments1001 /// 1002 /// * collection_id: ID of the Collection to remove admin for.1003 /// 1004 /// * account_id: Address of admin to remove.1005 #[weight = <T as Config>::WeightInfo::remove_collection_admin()]1006 #[transactional]1007 pub fn remove_collection_admin(origin, collection_id: CollectionId, account_id: T::CrossAccountId) -> DispatchResult {1008 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1009 let collection = Self::get_collection(collection_id)?;1010 Self::check_owner_or_admin_permissions(&collection, &sender)?;1011 let mut admin_arr = <AdminList<T>>::get(collection_id);10121013 match admin_arr.binary_search(&account_id) {1014 Ok(idx) => {1015 admin_arr.remove(idx);1016 <AdminList<T>>::insert(collection_id, admin_arr);1017 },1018 Err(_) => {}1019 }1020 Ok(())1021 }10221023 /// # Permissions1024 /// 1025 /// * Collection Owner1026 /// 1027 /// # Arguments1028 /// 1029 /// * collection_id.1030 /// 1031 /// * new_sponsor.1032 #[weight = <T as Config>::WeightInfo::set_collection_sponsor()]1033 #[transactional]1034 pub fn set_collection_sponsor(origin, collection_id: CollectionId, new_sponsor: T::AccountId) -> DispatchResult {1035 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1036 let mut target_collection = Self::get_collection(collection_id)?;1037 Self::check_owner_permissions(&target_collection, &sender)?;10381039 target_collection.sponsorship = SponsorshipState::Unconfirmed(new_sponsor);1040 Self::save_collection(target_collection);10411042 Ok(())1043 }10441045 /// # Permissions1046 /// 1047 /// * Sponsor.1048 /// 1049 /// # Arguments1050 /// 1051 /// * collection_id.1052 #[weight = <T as Config>::WeightInfo::confirm_sponsorship()]1053 #[transactional]1054 pub fn confirm_sponsorship(origin, collection_id: CollectionId) -> DispatchResult {1055 let sender = ensure_signed(origin)?;10561057 let mut target_collection = Self::get_collection(collection_id)?;1058 ensure!(1059 target_collection.sponsorship.pending_sponsor() == Some(&sender),1060 Error::<T>::ConfirmUnsetSponsorFail1061 );10621063 target_collection.sponsorship = SponsorshipState::Confirmed(sender);1064 Self::save_collection(target_collection);10651066 Ok(())1067 }10681069 /// Switch back to pay-per-own-transaction model.1070 ///1071 /// # Permissions1072 ///1073 /// * Collection owner.1074 /// 1075 /// # Arguments1076 /// 1077 /// * collection_id.1078 #[weight = <T as Config>::WeightInfo::remove_collection_sponsor()]1079 #[transactional]1080 pub fn remove_collection_sponsor(origin, collection_id: CollectionId) -> DispatchResult {1081 let sender = ensure_signed(origin)?;10821083 let mut target_collection = Self::get_collection(collection_id)?;1084 Self::check_owner_permissions(&target_collection, &T::CrossAccountId::from_sub(sender))?;10851086 target_collection.sponsorship = SponsorshipState::Disabled;1087 Self::save_collection(target_collection);10881089 Ok(())1090 }10911092 /// This method creates a concrete instance of NFT Collection created with CreateCollection method.1093 /// 1094 /// # Permissions1095 /// 1096 /// * Collection Owner.1097 /// * Collection Admin.1098 /// * Anyone if1099 /// * White List is enabled, and1100 /// * Address is added to white list, and1101 /// * MintPermission is enabled (see SetMintPermission method)1102 /// 1103 /// # Arguments1104 /// 1105 /// * collection_id: ID of the collection.1106 /// 1107 /// * owner: Address, initial owner of the NFT.1108 ///1109 /// * data: Token data to store on chain.1110 // #[weight =1111 // (130_000_000 as Weight)1112 // .saturating_add((2135 as Weight).saturating_mul((properties.len() as u64) as Weight))1113 // .saturating_add(RocksDbWeight::get().reads(10 as Weight))1114 // .saturating_add(RocksDbWeight::get().writes(8 as Weight))]11151116 #[weight = <T as Config>::WeightInfo::create_item(data.len())]1117 #[transactional]1118 pub fn create_item(origin, collection_id: CollectionId, owner: T::CrossAccountId, data: CreateItemData) -> DispatchResult {11191120 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);11211122 let target_collection = Self::get_collection(collection_id)?;11231124 Self::can_create_items_in_collection(&target_collection, &sender, &owner, 1)?;1125 Self::validate_create_item_args(&target_collection, &data)?;1126 Self::create_item_no_validation(&target_collection, owner, data)?;11271128 Ok(())1129 }11301131 /// This method creates multiple items in a collection created with CreateCollection method.1132 /// 1133 /// # Permissions1134 /// 1135 /// * Collection Owner.1136 /// * Collection Admin.1137 /// * Anyone if1138 /// * White List is enabled, and1139 /// * Address is added to white list, and1140 /// * MintPermission is enabled (see SetMintPermission method)1141 /// 1142 /// # Arguments1143 /// 1144 /// * collection_id: ID of the collection.1145 /// 1146 /// * itemsData: Array items properties. Each property is an array of bytes itself, see [create_item].1147 /// 1148 /// * owner: Address, initial owner of the NFT.1149 #[weight = <T as Config>::WeightInfo::create_item(items_data.into_iter()1150 .map(|data| { data.len() })1151 .sum())]1152 #[transactional]1153 pub fn create_multiple_items(origin, collection_id: CollectionId, owner: T::CrossAccountId, items_data: Vec<CreateItemData>) -> DispatchResult {11541155 ensure!(items_data.len() > 0, Error::<T>::EmptyArgument);1156 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1157 let collection = Self::get_collection(collection_id)?;11581159 Self::create_multiple_items_internal(sender, &collection, owner, items_data)?;11601161 Ok(())1162 }11631164 /// Destroys a concrete instance of NFT.1165 /// 1166 /// # Permissions1167 /// 1168 /// * Collection Owner.1169 /// * Collection Admin.1170 /// * Current NFT Owner.1171 /// 1172 /// # Arguments1173 /// 1174 /// * collection_id: ID of the collection.1175 /// 1176 /// * item_id: ID of NFT to burn.1177 #[weight = <T as Config>::WeightInfo::burn_item()]1178 #[transactional]1179 pub fn burn_item(origin, collection_id: CollectionId, item_id: TokenId, value: u128) -> DispatchResult {11801181 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1182 let target_collection = Self::get_collection(collection_id)?;11831184 Self::burn_item_internal(&sender, &target_collection, item_id, value)?;11851186 Ok(())1187 }11881189 /// Change ownership of the token.1190 /// 1191 /// # Permissions1192 /// 1193 /// * Collection Owner1194 /// * Collection Admin1195 /// * Current NFT owner1196 ///1197 /// # Arguments1198 /// 1199 /// * recipient: Address of token recipient.1200 /// 1201 /// * collection_id.1202 /// 1203 /// * item_id: ID of the item1204 /// * Non-Fungible Mode: Required.1205 /// * Fungible Mode: Ignored.1206 /// * Re-Fungible Mode: Required.1207 /// 1208 /// * value: Amount to transfer.1209 /// * Non-Fungible Mode: Ignored1210 /// * Fungible Mode: Must specify transferred amount1211 /// * Re-Fungible Mode: Must specify transferred portion (between 0 and 1)1212 #[weight = <T as Config>::WeightInfo::transfer()]1213 #[transactional]1214 pub fn transfer(origin, recipient: T::CrossAccountId, collection_id: CollectionId, item_id: TokenId, value: u128) -> DispatchResult {1215 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1216 let collection = Self::get_collection(collection_id)?;12171218 Self::transfer_internal(sender, recipient, &collection, item_id, value)?;12191220 Ok(())1221 }12221223 /// Set, change, or remove approved address to transfer the ownership of the NFT.1224 /// 1225 /// # Permissions1226 /// 1227 /// * Collection Owner1228 /// * Collection Admin1229 /// * Current NFT owner1230 /// 1231 /// # Arguments1232 /// 1233 /// * approved: Address that is approved to transfer this NFT or zero (if needed to remove approval).1234 /// 1235 /// * collection_id.1236 /// 1237 /// * item_id: ID of the item.1238 #[weight = <T as Config>::WeightInfo::approve()]1239 #[transactional]1240 pub fn approve(origin, spender: T::CrossAccountId, collection_id: CollectionId, item_id: TokenId, amount: u128) -> DispatchResult {12411242 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1243 let collection = Self::get_collection(collection_id)?;12441245 Self::approve_internal(sender, spender, &collection, item_id, amount)?;12461247 Ok(())1248 }1249 1250 /// 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.1251 /// 1252 /// # Permissions1253 /// * Collection Owner1254 /// * Collection Admin1255 /// * Current NFT owner1256 /// * Address approved by current NFT owner1257 /// 1258 /// # Arguments1259 /// 1260 /// * from: Address that owns token.1261 /// 1262 /// * recipient: Address of token recipient.1263 /// 1264 /// * collection_id.1265 /// 1266 /// * item_id: ID of the item.1267 /// 1268 /// * value: Amount to transfer.1269 #[weight = <T as Config>::WeightInfo::transfer_from()]1270 #[transactional]1271 pub fn transfer_from(origin, from: T::CrossAccountId, recipient: T::CrossAccountId, collection_id: CollectionId, item_id: TokenId, value: u128 ) -> DispatchResult {12721273 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1274 let collection = Self::get_collection(collection_id)?;12751276 Self::transfer_from_internal(sender, from, recipient, &collection, item_id, value)?;12771278 Ok(())1279 }12801281 // #[weight = 0]1282 // pub fn safe_transfer_from(origin, collection_id: CollectionId, item_id: TokenId, new_owner: T::AccountId) -> DispatchResult {12831284 // // let no_perm_mes = "You do not have permissions to modify this collection";1285 // // ensure!(<ApprovedList<T>>::contains_key((collection_id, item_id)), no_perm_mes);1286 // // let list_itm = <ApprovedList<T>>::get((collection_id, item_id));1287 // // ensure!(list_itm.contains(&new_owner.clone()), no_perm_mes);12881289 // // // on_nft_received call12901291 // // Self::transfer(origin, collection_id, item_id, new_owner)?;12921293 // Ok(())1294 // }12951296 /// Set off-chain data schema.1297 /// 1298 /// # Permissions1299 /// 1300 /// * Collection Owner1301 /// * Collection Admin1302 /// 1303 /// # Arguments1304 /// 1305 /// * collection_id.1306 /// 1307 /// * schema: String representing the offchain data schema.1308 #[weight = <T as Config>::WeightInfo::set_variable_meta_data()]1309 #[transactional]1310 pub fn set_variable_meta_data (1311 origin,1312 collection_id: CollectionId,1313 item_id: TokenId,1314 data: Vec<u8>1315 ) -> DispatchResult {1316 let sender = ensure_signed(origin)?;1317 1318 let target_collection = Self::get_collection(collection_id)?;1319 Self::token_exists(&target_collection, item_id)?;13201321 ensure!(ChainLimit::get().custom_data_limit >= data.len() as u32, Error::<T>::TokenVariableDataLimitExceeded);13221323 // Modify permissions check1324 ensure!(Self::is_item_owner(sender.clone(), &target_collection, item_id) ||1325 Self::is_owner_or_admin_permissions(&target_collection, sender.clone()),1326 Error::<T>::NoPermission);13271328 match target_collection.mode1329 {1330 CollectionMode::NFT => Self::set_nft_variable_data(&target_collection, item_id, data)?,1331 CollectionMode::ReFungible => Self::set_re_fungible_variable_data(&target_collection, item_id, data)?,1332 CollectionMode::Fungible(_) => fail!(Error::<T>::CantStoreMetadataInFungibleTokens),1333 _ => fail!(Error::<T>::UnexpectedCollectionType)1334 };13351336 Ok(())1337 }1338 1339 /// Set schema standard1340 /// ImageURL1341 /// Unique1342 /// 1343 /// # Permissions1344 /// 1345 /// * Collection Owner1346 /// * Collection Admin1347 /// 1348 /// # Arguments1349 /// 1350 /// * collection_id.1351 /// 1352 /// * schema: SchemaVersion: enum1353 #[weight = <T as Config>::WeightInfo::set_schema_version()]1354 #[transactional]1355 pub fn set_schema_version(1356 origin,1357 collection_id: CollectionId,1358 version: SchemaVersion1359 ) -> DispatchResult {1360 let sender = ensure_signed(origin)?;1361 let mut target_collection = Self::get_collection(collection_id)?;1362 Self::check_owner_or_admin_permissions(&target_collection, &sender)?;1363 target_collection.schema_version = version;1364 Self::save_collection(target_collection);13651366 Ok(())1367 }13681369 /// Set off-chain data schema.1370 /// 1371 /// # Permissions1372 /// 1373 /// * Collection Owner1374 /// * Collection Admin1375 /// 1376 /// # Arguments1377 /// 1378 /// * collection_id.1379 /// 1380 /// * schema: String representing the offchain data schema.1381 #[weight = <T as Config>::WeightInfo::set_offchain_schema()]1382 #[transactional]1383 pub fn set_offchain_schema(1384 origin,1385 collection_id: CollectionId,1386 schema: Vec<u8>1387 ) -> DispatchResult {1388 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1389 let mut target_collection = Self::get_collection(collection_id)?;1390 Self::check_owner_or_admin_permissions(&target_collection, &sender)?;13911392 // check schema limit1393 ensure!(schema.len() as u32 <= ChainLimit::get().offchain_schema_limit, "");13941395 target_collection.offchain_schema = schema;1396 Self::save_collection(target_collection);13971398 Ok(())1399 }14001401 /// Set const on-chain data schema.1402 /// 1403 /// # Permissions1404 /// 1405 /// * Collection Owner1406 /// * Collection Admin1407 /// 1408 /// # Arguments1409 /// 1410 /// * collection_id.1411 /// 1412 /// * schema: String representing the const on-chain data schema.1413 #[weight = <T as Config>::WeightInfo::set_const_on_chain_schema()]1414 #[transactional]1415 pub fn set_const_on_chain_schema (1416 origin,1417 collection_id: CollectionId,1418 schema: Vec<u8>1419 ) -> DispatchResult {1420 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1421 let mut target_collection = Self::get_collection(collection_id)?;1422 Self::check_owner_or_admin_permissions(&target_collection, &sender)?;14231424 // check schema limit1425 ensure!(schema.len() as u32 <= ChainLimit::get().const_on_chain_schema_limit, "");14261427 target_collection.const_on_chain_schema = schema;1428 Self::save_collection(target_collection);14291430 Ok(())1431 }14321433 /// Set variable on-chain data schema.1434 /// 1435 /// # Permissions1436 /// 1437 /// * Collection Owner1438 /// * Collection Admin1439 /// 1440 /// # Arguments1441 /// 1442 /// * collection_id.1443 /// 1444 /// * schema: String representing the variable on-chain data schema.1445 #[weight = <T as Config>::WeightInfo::set_const_on_chain_schema()]1446 #[transactional]1447 pub fn set_variable_on_chain_schema (1448 origin,1449 collection_id: CollectionId,1450 schema: Vec<u8>1451 ) -> DispatchResult {1452 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1453 let mut target_collection = Self::get_collection(collection_id)?;1454 Self::check_owner_or_admin_permissions(&target_collection, &sender)?;14551456 // check schema limit1457 ensure!(schema.len() as u32 <= ChainLimit::get().variable_on_chain_schema_limit, "");14581459 target_collection.variable_on_chain_schema = schema;1460 Self::save_collection(target_collection);14611462 Ok(())1463 }14641465 // Sudo permissions function1466 #[weight = <T as Config>::WeightInfo::set_chain_limits()]1467 #[transactional]1468 pub fn set_chain_limits(1469 origin,1470 limits: ChainLimits1471 ) -> DispatchResult {14721473 #[cfg(not(feature = "runtime-benchmarks"))]1474 ensure_root(origin)?;14751476 <ChainLimit>::put(limits);1477 Ok(())1478 }14791480 /// Enable smart contract self-sponsoring.1481 /// 1482 /// # Permissions1483 /// 1484 /// * Contract Owner1485 /// 1486 /// # Arguments1487 /// 1488 /// * contract address1489 /// * enable flag1490 /// 1491 #[weight = <T as Config>::WeightInfo::enable_contract_sponsoring()]1492 #[transactional]1493 pub fn enable_contract_sponsoring(1494 origin,1495 contract_address: T::AccountId,1496 enable: bool1497 ) -> DispatchResult {14981499 let sender = ensure_signed(origin)?;15001501 #[cfg(feature = "runtime-benchmarks")]1502 <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());15031504 Self::ensure_contract_owned(sender, &contract_address)?;15051506 <ContractSelfSponsoring<T>>::insert(contract_address, enable);1507 Ok(())1508 }15091510 /// Set the rate limit for contract sponsoring to specified number of blocks.1511 /// 1512 /// If not set (has the default value of 0 blocks), the sponsoring will be disabled. 1513 /// If set to the number B (for blocks), the transactions will be sponsored with a rate 1514 /// limit of B, i.e. fees for every transaction sent to this smart contract will be paid 1515 /// from contract endowment if there are at least B blocks between such transactions. 1516 /// Nonetheless, if transactions are sent more frequently, the fees are paid by the sender.1517 /// 1518 /// # Permissions1519 /// 1520 /// * Contract Owner1521 /// 1522 /// # Arguments1523 /// 1524 /// -`contract_address`: Address of the contract to sponsor1525 /// -`rate_limit`: Number of blocks to wait until the next sponsored transaction is allowed1526 /// 1527 #[weight = <T as Config>::WeightInfo::set_contract_sponsoring_rate_limit()]1528 #[transactional]1529 pub fn set_contract_sponsoring_rate_limit(1530 origin,1531 contract_address: T::AccountId,1532 rate_limit: T::BlockNumber1533 ) -> DispatchResult {1534 let sender = ensure_signed(origin)?;15351536 #[cfg(feature = "runtime-benchmarks")]1537 <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());15381539 Self::ensure_contract_owned(sender, &contract_address)?;1540 <ContractSponsoringRateLimit<T>>::insert(contract_address, rate_limit);1541 Ok(())1542 }15431544 /// Enable the white list for a contract. Only addresses added to the white list with addToContractWhiteList will be able to call this smart contract.1545 /// 1546 /// # Permissions1547 /// 1548 /// * Address that deployed smart contract.1549 /// 1550 /// # Arguments1551 /// 1552 /// -`contract_address`: Address of the contract.1553 /// 1554 /// - `enable`: . 1555 #[weight = <T as Config>::WeightInfo::toggle_contract_white_list()]1556 #[transactional]1557 pub fn toggle_contract_white_list(1558 origin,1559 contract_address: T::AccountId,1560 enable: bool1561 ) -> DispatchResult {1562 let sender = ensure_signed(origin)?;15631564 #[cfg(feature = "runtime-benchmarks")]1565 <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());15661567 Self::ensure_contract_owned(sender, &contract_address)?;1568 if enable {1569 <ContractWhiteListEnabled<T>>::insert(contract_address, true);1570 } else {1571 <ContractWhiteListEnabled<T>>::remove(contract_address);1572 }1573 Ok(())1574 }1575 1576 /// Add an address to smart contract white list.1577 /// 1578 /// # Permissions1579 /// 1580 /// * Address that deployed smart contract.1581 /// 1582 /// # Arguments1583 /// 1584 /// -`contract_address`: Address of the contract.1585 ///1586 /// -`account_address`: Address to add.1587 #[weight = <T as Config>::WeightInfo::add_to_contract_white_list()]1588 #[transactional]1589 pub fn add_to_contract_white_list(1590 origin,1591 contract_address: T::AccountId,1592 account_address: T::AccountId1593 ) -> DispatchResult {1594 let sender = ensure_signed(origin)?;15951596 #[cfg(feature = "runtime-benchmarks")]1597 <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());1598 1599 Self::ensure_contract_owned(sender, &contract_address)?; 1600 <ContractWhiteList<T>>::insert(contract_address, account_address, true);1601 Ok(())1602 }16031604 /// Remove an address from smart contract white list.1605 /// 1606 /// # Permissions1607 /// 1608 /// * Address that deployed smart contract.1609 /// 1610 /// # Arguments1611 /// 1612 /// -`contract_address`: Address of the contract.1613 ///1614 /// -`account_address`: Address to remove.1615 #[weight = <T as Config>::WeightInfo::remove_from_contract_white_list()]1616 #[transactional]1617 pub fn remove_from_contract_white_list(1618 origin,1619 contract_address: T::AccountId,1620 account_address: T::AccountId1621 ) -> DispatchResult {1622 let sender = ensure_signed(origin)?;16231624 #[cfg(feature = "runtime-benchmarks")]1625 <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());16261627 Self::ensure_contract_owned(sender, &contract_address)?;1628 <ContractWhiteList<T>>::remove(contract_address, account_address);1629 Ok(())1630 }16311632 #[weight = <T as Config>::WeightInfo::set_collection_limits()]1633 #[transactional]1634 pub fn set_collection_limits(1635 origin,1636 collection_id: u32,1637 new_limits: CollectionLimits<T::BlockNumber>,1638 ) -> DispatchResult {1639 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1640 let mut target_collection = Self::get_collection(collection_id)?;1641 Self::check_owner_permissions(&target_collection, &sender)?;1642 let old_limits = &target_collection.limits;1643 let chain_limits = ChainLimit::get();16441645 // collection bounds1646 ensure!(new_limits.sponsor_transfer_timeout <= MAX_SPONSOR_TIMEOUT &&1647 new_limits.account_token_ownership_limit <= MAX_TOKEN_OWNERSHIP && 1648 new_limits.sponsored_data_size <= chain_limits.custom_data_limit,1649 Error::<T>::CollectionLimitBoundsExceeded);16501651 // token_limit check prev1652 ensure!(old_limits.token_limit >= new_limits.token_limit, Error::<T>::CollectionTokenLimitExceeded);1653 ensure!(new_limits.token_limit > 0, Error::<T>::CollectionTokenLimitExceeded);16541655 ensure!(1656 (old_limits.owner_can_transfer || !new_limits.owner_can_transfer) &&1657 (old_limits.owner_can_destroy || !new_limits.owner_can_destroy),1658 Error::<T>::OwnerPermissionsCantBeReverted,1659 );16601661 target_collection.limits = new_limits;1662 Self::save_collection(target_collection);16631664 Ok(())1665 } 1666 }1667}16681669impl<T: Config> Module<T> {16701671 pub fn transfer_internal(sender: T::CrossAccountId, recipient: T::CrossAccountId, target_collection: &CollectionHandle<T>, item_id: TokenId, value: u128) -> DispatchResult {1672 // Limits check1673 Self::is_correct_transfer(target_collection, &recipient)?;16741675 // Transfer permissions check1676 ensure!(Self::is_item_owner(&sender, target_collection, item_id) ||1677 Self::is_owner_or_admin_permissions(target_collection, &sender),1678 Error::<T>::NoPermission);16791680 if target_collection.access == AccessMode::WhiteList {1681 Self::check_white_list(target_collection, &sender)?;1682 Self::check_white_list(target_collection, &recipient)?;1683 }16841685 match target_collection.mode1686 {1687 CollectionMode::NFT => Self::transfer_nft(target_collection, item_id, sender.clone(), recipient.clone())?,1688 CollectionMode::Fungible(_) => Self::transfer_fungible(target_collection, value, &sender, &recipient)?,1689 CollectionMode::ReFungible => Self::transfer_refungible(target_collection, item_id, value, sender.clone(), recipient.clone())?,1690 _ => ()1691 };16921693 Self::deposit_event(RawEvent::Transfer(target_collection.id, item_id, sender, recipient, value));16941695 Ok(())1696 }16971698 pub fn approve_internal(1699 sender: T::CrossAccountId,1700 spender: T::CrossAccountId,1701 collection: &CollectionHandle<T>,1702 item_id: TokenId,1703 amount: u1281704 ) -> DispatchResult {1705 Self::token_exists(&collection, item_id)?;17061707 // Transfer permissions check1708 let bypasses_limits = collection.limits.owner_can_transfer &&1709 Self::is_owner_or_admin_permissions(1710 &collection,1711 &sender,1712 );17131714 let allowance_limit = if bypasses_limits {1715 None1716 } else if let Some(amount) = Self::owned_amount(1717 &sender,1718 &collection,1719 item_id,1720 ) {1721 Some(amount)1722 } else {1723 fail!(Error::<T>::NoPermission);1724 };17251726 if collection.access == AccessMode::WhiteList {1727 Self::check_white_list(&collection, &sender)?;1728 Self::check_white_list(&collection, &spender)?;1729 }17301731 let allowance: u128 = amount1732 .checked_add(<Allowances<T>>::get(collection.id, (item_id, sender.as_sub(), spender.as_sub())))1733 .ok_or(Error::<T>::NumOverflow)?;1734 if let Some(limit) = allowance_limit {1735 ensure!(limit >= allowance, Error::<T>::TokenValueTooLow);1736 }1737 <Allowances<T>>::insert(collection.id, (item_id, sender.as_sub(), spender.as_sub()), allowance);173817391740 Self::deposit_event(RawEvent::Approved(collection.id, item_id, sender, spender, allowance));1741 Ok(())1742 }17431744 pub fn transfer_from_internal(1745 sender: T::CrossAccountId,1746 from: T::CrossAccountId,1747 recipient: T::CrossAccountId,1748 collection: &CollectionHandle<T>,1749 item_id: TokenId,1750 amount: u128,1751 ) -> DispatchResult {1752 // Check approval1753 let approval: u128 = <Allowances<T>>::get(collection.id, (item_id, from.as_sub(), sender.as_sub()));17541755 // Limits check1756 Self::is_correct_transfer(&collection, &recipient)?;17571758 // Transfer permissions check1759 ensure!(1760 approval >= amount || 1761 (1762 collection.limits.owner_can_transfer &&1763 Self::is_owner_or_admin_permissions(&collection, &sender)1764 ),1765 Error::<T>::NoPermission1766 );17671768 if collection.access == AccessMode::WhiteList {1769 Self::check_white_list(&collection, &sender)?;1770 Self::check_white_list(&collection, &recipient)?;1771 }17721773 // Reduce approval by transferred amount or remove if remaining approval drops to 01774 let allowance = approval.saturating_sub(amount);1775 if allowance > 0 {1776 <Allowances<T>>::insert(collection.id, (item_id, from.as_sub(), sender.as_sub()), allowance);1777 } else {1778 <Allowances<T>>::remove(collection.id, (item_id, from.as_sub(), sender.as_sub()));1779 }17801781 match collection.mode {1782 CollectionMode::NFT => {1783 Self::transfer_nft(&collection, item_id, from.clone(), recipient.clone())?1784 }1785 CollectionMode::Fungible(_) => {1786 Self::transfer_fungible(&collection, amount, &from, &recipient)?1787 }1788 CollectionMode::ReFungible => {1789 Self::transfer_refungible(&collection, item_id, amount, from.clone(), recipient.clone())?1790 }1791 _ => ()1792 };17931794 Ok(())1795 }17961797 pub fn create_multiple_items_internal(1798 sender: T::CrossAccountId,1799 collection: &CollectionHandle<T>,1800 owner: T::CrossAccountId,1801 items_data: Vec<CreateItemData>,1802 ) -> DispatchResult {1803 Self::can_create_items_in_collection(&collection, &sender, &owner, items_data.len() as u32)?;18041805 for data in &items_data {1806 Self::validate_create_item_args(&collection, data)?;1807 }1808 for data in &items_data {1809 Self::create_item_no_validation(&collection, owner.clone(), data.clone())?;1810 }18111812 Ok(())1813 }18141815 pub fn burn_item_internal(1816 sender: &T::CrossAccountId,1817 collection: &CollectionHandle<T>,1818 item_id: TokenId,1819 value: u128,1820 ) -> DispatchResult {1821 ensure!(1822 Self::is_item_owner(&sender, &collection, item_id) ||1823 (1824 collection.limits.owner_can_transfer &&1825 Self::is_owner_or_admin_permissions(&collection, &sender)1826 ),1827 Error::<T>::NoPermission1828 );18291830 if collection.access == AccessMode::WhiteList {1831 Self::check_white_list(&collection, &sender)?;1832 }18331834 match collection.mode1835 {1836 CollectionMode::NFT => Self::burn_nft_item(&collection, item_id)?,1837 CollectionMode::Fungible(_) => Self::burn_fungible_item(&sender, &collection, value)?,1838 CollectionMode::ReFungible => Self::burn_refungible_item(&collection, item_id, &sender)?,1839 _ => ()1840 };18411842 Ok(())1843 }18441845 fn is_correct_transfer(collection: &CollectionHandle<T>, recipient: &T::CrossAccountId) -> DispatchResult {1846 let collection_id = collection.id;18471848 // check token limit and account token limit1849 let account_items: u32 = <AddressTokens<T>>::get(collection_id, recipient.as_sub()).len() as u32;1850 ensure!(collection.limits.account_token_ownership_limit > account_items, Error::<T>::AccountTokenLimitExceeded);1851 1852 Ok(())1853 }18541855 fn can_create_items_in_collection(collection: &CollectionHandle<T>, sender: &T::CrossAccountId, owner: &T::CrossAccountId, amount: u32) -> DispatchResult {1856 let collection_id = collection.id;18571858 // check token limit and account token limit1859 let total_items: u32 = ItemListIndex::get(collection_id)1860 .checked_add(amount)1861 .ok_or(Error::<T>::CollectionTokenLimitExceeded)?;1862 let account_items: u32 = (<AddressTokens<T>>::get(collection_id, owner.as_sub()).len() as u32)1863 .checked_add(amount)1864 .ok_or(Error::<T>::AccountTokenLimitExceeded)?;1865 ensure!(collection.limits.token_limit >= total_items, Error::<T>::CollectionTokenLimitExceeded);1866 ensure!(collection.limits.account_token_ownership_limit >= account_items, Error::<T>::AccountTokenLimitExceeded);18671868 if !Self::is_owner_or_admin_permissions(collection, &sender) {1869 ensure!(collection.mint_mode == true, Error::<T>::PublicMintingNotAllowed);1870 Self::check_white_list(collection, owner)?;1871 Self::check_white_list(collection, sender)?;1872 }18731874 Ok(())1875 }18761877 fn validate_create_item_args(target_collection: &CollectionHandle<T>, data: &CreateItemData) -> DispatchResult {1878 match target_collection.mode1879 {1880 CollectionMode::NFT => {1881 if let CreateItemData::NFT(data) = data {1882 // check sizes1883 ensure!(ChainLimit::get().custom_data_limit >= data.const_data.len() as u32, Error::<T>::TokenConstDataLimitExceeded);1884 ensure!(ChainLimit::get().custom_data_limit >= data.variable_data.len() as u32, Error::<T>::TokenVariableDataLimitExceeded);1885 } else {1886 fail!(Error::<T>::NotNftDataUsedToMintNftCollectionToken);1887 }1888 },1889 CollectionMode::Fungible(_) => {1890 if let CreateItemData::Fungible(_) = data {1891 } else {1892 fail!(Error::<T>::NotFungibleDataUsedToMintFungibleCollectionToken);1893 }1894 },1895 CollectionMode::ReFungible => {1896 if let CreateItemData::ReFungible(data) = data {18971898 // check sizes1899 ensure!(ChainLimit::get().custom_data_limit >= data.const_data.len() as u32, Error::<T>::TokenConstDataLimitExceeded);1900 ensure!(ChainLimit::get().custom_data_limit >= data.variable_data.len() as u32, Error::<T>::TokenVariableDataLimitExceeded);19011902 // Check refungibility limits1903 ensure!(data.pieces <= MAX_REFUNGIBLE_PIECES, Error::<T>::WrongRefungiblePieces);1904 ensure!(data.pieces > 0, Error::<T>::WrongRefungiblePieces);1905 } else {1906 fail!(Error::<T>::NotReFungibleDataUsedToMintReFungibleCollectionToken);1907 }1908 },1909 _ => { fail!(Error::<T>::UnexpectedCollectionType); }1910 };19111912 Ok(())1913 }19141915 fn create_item_no_validation(collection: &CollectionHandle<T>, owner: T::CrossAccountId, data: CreateItemData) -> DispatchResult {1916 match data1917 {1918 CreateItemData::NFT(data) => {1919 let item = NftItemType {1920 owner: owner.clone(),1921 const_data: data.const_data,1922 variable_data: data.variable_data1923 };19241925 Self::add_nft_item(collection, item)?;1926 },1927 CreateItemData::Fungible(data) => {1928 Self::add_fungible_item(collection, &owner, data.value)?;1929 },1930 CreateItemData::ReFungible(data) => {1931 let mut owner_list = Vec::new();1932 owner_list.push(Ownership {owner: owner.clone(), fraction: data.pieces});19331934 let item = ReFungibleItemType {1935 owner: owner_list,1936 const_data: data.const_data,1937 variable_data: data.variable_data1938 };19391940 Self::add_refungible_item(collection, item)?;1941 }1942 };19431944 Ok(())1945 }19461947 fn add_fungible_item(collection: &CollectionHandle<T>, owner: &T::CrossAccountId, value: u128) -> DispatchResult {1948 let collection_id = collection.id;19491950 // Does new owner already have an account?1951 let balance: u128 = <FungibleItemList<T>>::get(collection_id, owner.as_sub()).value;19521953 // Mint 1954 let item = FungibleItemType {1955 value: balance.checked_add(value).ok_or(Error::<T>::NumOverflow)?,1956 };1957 <FungibleItemList<T>>::insert(collection_id, owner.as_sub(), item);19581959 // Update balance1960 let new_balance = <Balance<T>>::get(collection_id, owner.as_sub())1961 .checked_add(value)1962 .ok_or(Error::<T>::NumOverflow)?;1963 <Balance<T>>::insert(collection_id, owner.as_sub(), new_balance);19641965 Self::deposit_event(RawEvent::ItemCreated(collection_id, 0, owner.clone()));1966 Ok(())1967 }19681969 fn add_refungible_item(collection: &CollectionHandle<T>, item: ReFungibleItemType<T::CrossAccountId>) -> DispatchResult {1970 let collection_id = collection.id;19711972 let current_index = <ItemListIndex>::get(collection_id)1973 .checked_add(1)1974 .ok_or(Error::<T>::NumOverflow)?;1975 let itemcopy = item.clone();19761977 ensure!(1978 item.owner.len() == 1,1979 Error::<T>::BadCreateRefungibleCall,1980 );1981 let item_owner = item.owner.first().expect("only one owner is defined");19821983 let value = item_owner.fraction;1984 let owner = item_owner.owner.clone();19851986 Self::add_token_index(collection_id, current_index, &owner)?;19871988 <ItemListIndex>::insert(collection_id, current_index);1989 <ReFungibleItemList<T>>::insert(collection_id, current_index, itemcopy);19901991 // Update balance1992 let new_balance = <Balance<T>>::get(collection_id, owner.as_sub())1993 .checked_add(value)1994 .ok_or(Error::<T>::NumOverflow)?;1995 <Balance<T>>::insert(collection_id, owner.as_sub(), new_balance);19961997 Self::deposit_event(RawEvent::ItemCreated(collection_id, current_index, owner));1998 Ok(())1999 }20002001 fn add_nft_item(collection: &CollectionHandle<T>, item: NftItemType<T::CrossAccountId>) -> DispatchResult {2002 let collection_id = collection.id;20032004 let current_index = <ItemListIndex>::get(collection_id)2005 .checked_add(1)2006 .ok_or(Error::<T>::NumOverflow)?;20072008 let item_owner = item.owner.clone();2009 Self::add_token_index(collection_id, current_index, &item.owner)?;20102011 <ItemListIndex>::insert(collection_id, current_index);2012 <NftItemList<T>>::insert(collection_id, current_index, item);20132014 // Update balance2015 let new_balance = <Balance<T>>::get(collection_id, item_owner.as_sub())2016 .checked_add(1)2017 .ok_or(Error::<T>::NumOverflow)?;2018 <Balance<T>>::insert(collection_id, item_owner.as_sub(), new_balance);20192020 Self::deposit_event(RawEvent::ItemCreated(collection_id, current_index, item_owner));2021 Ok(())2022 }20232024 fn burn_refungible_item(2025 collection: &CollectionHandle<T>,2026 item_id: TokenId,2027 owner: &T::CrossAccountId,2028 ) -> DispatchResult {2029 let collection_id = collection.id;20302031 let mut token = <ReFungibleItemList<T>>::get(collection_id, item_id)2032 .ok_or(Error::<T>::TokenNotFound)?;2033 let rft_balance = token2034 .owner2035 .iter()2036 .find(|&i| i.owner == *owner)2037 .ok_or(Error::<T>::TokenNotFound)?;2038 Self::remove_token_index(collection_id, item_id, owner)?;20392040 // update balance2041 let new_balance = <Balance<T>>::get(collection_id, rft_balance.owner.as_sub())2042 .checked_sub(rft_balance.fraction)2043 .ok_or(Error::<T>::NumOverflow)?;2044 <Balance<T>>::insert(collection_id, rft_balance.owner.as_sub(), new_balance);20452046 // Re-create owners list with sender removed2047 let index = token2048 .owner2049 .iter()2050 .position(|i| i.owner == *owner)2051 .expect("owned item is exists");2052 token.owner.remove(index);2053 let owner_count = token.owner.len();20542055 // Burn the token completely if this was the last (only) owner2056 if owner_count == 0 {2057 <ReFungibleItemList<T>>::remove(collection_id, item_id);2058 <VariableMetaDataBasket<T>>::remove(collection_id, item_id);2059 }2060 else {2061 <ReFungibleItemList<T>>::insert(collection_id, item_id, token);2062 }20632064 Ok(())2065 }20662067 fn burn_nft_item(collection: &CollectionHandle<T>, item_id: TokenId) -> DispatchResult {2068 let collection_id = collection.id;20692070 let item = <NftItemList<T>>::get(collection_id, item_id)2071 .ok_or(Error::<T>::TokenNotFound)?;2072 Self::remove_token_index(collection_id, item_id, &item.owner)?;20732074 // update balance2075 let new_balance = <Balance<T>>::get(collection_id, item.owner.as_sub())2076 .checked_sub(1)2077 .ok_or(Error::<T>::NumOverflow)?;2078 <Balance<T>>::insert(collection_id, item.owner.as_sub(), new_balance);2079 <NftItemList<T>>::remove(collection_id, item_id);2080 <VariableMetaDataBasket<T>>::remove(collection_id, item_id);20812082 Self::deposit_event(RawEvent::ItemDestroyed(collection.id, item_id));2083 Ok(())2084 }20852086 fn burn_fungible_item(owner: &T::CrossAccountId, collection: &CollectionHandle<T>, value: u128) -> DispatchResult {2087 let collection_id = collection.id;20882089 let mut balance = <FungibleItemList<T>>::get(collection_id, owner.as_sub());2090 ensure!(balance.value >= value, Error::<T>::TokenValueNotEnough);20912092 // update balance2093 let new_balance = <Balance<T>>::get(collection_id, owner.as_sub())2094 .checked_sub(value)2095 .ok_or(Error::<T>::NumOverflow)?;2096 <Balance<T>>::insert(collection_id, owner.as_sub(), new_balance);20972098 if balance.value - value > 0 {2099 balance.value -= value;2100 <FungibleItemList<T>>::insert(collection_id, owner.as_sub(), balance);2101 }2102 else {2103 <FungibleItemList<T>>::remove(collection_id, owner.as_sub());2104 }21052106 Ok(())2107 }21082109 pub fn get_collection(collection_id: CollectionId) -> Result<CollectionHandle<T>, sp_runtime::DispatchError> {2110 Ok(<CollectionById<T>>::get(collection_id)2111 .map(|collection| CollectionHandle {2112 id: collection_id,2113 collection2114 })2115 .ok_or(Error::<T>::CollectionNotFound)?)2116 }21172118 fn save_collection(collection: CollectionHandle<T>) {2119 <CollectionById<T>>::insert(collection.id, collection.collection);2120 }212121222123 fn check_owner_permissions(target_collection: &CollectionHandle<T>, subject: &T::CrossAccountId) -> DispatchResult {2124 ensure!(2125 *subject == target_collection.owner,2126 Error::<T>::NoPermission2127 );21282129 Ok(())2130 }21312132 fn is_owner_or_admin_permissions(collection: &CollectionHandle<T>, subject: &T::CrossAccountId) -> bool {2133 *subject == collection.owner || <AdminList<T>>::get(collection.id).contains(&subject)2134 }21352136 fn check_owner_or_admin_permissions(2137 collection: &CollectionHandle<T>,2138 subject: &T::CrossAccountId,2139 ) -> DispatchResult {2140 ensure!(Self::is_owner_or_admin_permissions(collection, subject), Error::<T>::NoPermission);21412142 Ok(())2143 }21442145 fn owned_amount(2146 subject: &T::CrossAccountId,2147 target_collection: &CollectionHandle<T>,2148 item_id: TokenId,2149 ) -> Option<u128> {2150 let collection_id = target_collection.id;21512152 match target_collection.mode {2153 CollectionMode::NFT => (<NftItemList<T>>::get(collection_id, item_id)?.owner == *subject)2154 .then(|| 1),2155 CollectionMode::Fungible(_) => Some(<FungibleItemList<T>>::get(collection_id, &subject.as_sub())2156 .value),2157 CollectionMode::ReFungible => <ReFungibleItemList<T>>::get(collection_id, item_id)?2158 .owner2159 .iter()2160 .find(|i| i.owner == *subject)2161 .map(|i| i.fraction),2162 CollectionMode::Invalid => None,2163 }2164 }21652166 fn is_item_owner(subject: &T::CrossAccountId, target_collection: &CollectionHandle<T>, item_id: TokenId) -> bool {2167 match target_collection.mode {2168 CollectionMode::Fungible(_) => true,2169 _ => Self::owned_amount(&subject, target_collection, item_id).is_some(),2170 }2171 }21722173 fn check_white_list(collection: &CollectionHandle<T>, address: &T::CrossAccountId) -> DispatchResult {2174 let collection_id = collection.id;21752176 let mes = Error::<T>::AddresNotInWhiteList;2177 ensure!(<WhiteList<T>>::contains_key(collection_id, address.as_sub()), mes);21782179 Ok(())2180 }21812182 /// Check if token exists. In case of Fungible, check if there is an entry for 2183 /// the owner in fungible balances double map2184 fn token_exists(2185 target_collection: &CollectionHandle<T>,2186 item_id: TokenId,2187 ) -> DispatchResult {2188 let collection_id = target_collection.id;2189 let exists = match target_collection.mode2190 {2191 CollectionMode::NFT => <NftItemList<T>>::contains_key(collection_id, item_id),2192 CollectionMode::Fungible(_) => true,2193 CollectionMode::ReFungible => <ReFungibleItemList<T>>::contains_key(collection_id, item_id),2194 _ => false2195 };21962197 ensure!(exists == true, Error::<T>::TokenNotFound);2198 Ok(())2199 }22002201 fn transfer_fungible(2202 collection: &CollectionHandle<T>,2203 value: u128,2204 owner: &T::CrossAccountId,2205 recipient: &T::CrossAccountId,2206 ) -> DispatchResult {2207 let collection_id = collection.id;22082209 let mut balance = <FungibleItemList<T>>::get(collection_id, owner.as_sub());2210 ensure!(balance.value >= value, Error::<T>::TokenValueTooLow);22112212 // Send balance to recipient (updates balanceOf of recipient)2213 Self::add_fungible_item(collection, recipient, value)?;22142215 // update balanceOf of sender2216 <Balance<T>>::insert(collection_id, owner.as_sub(), balance.value - value);22172218 // Reduce or remove sender2219 if balance.value == value {2220 <FungibleItemList<T>>::remove(collection_id, owner.as_sub());2221 }2222 else {2223 balance.value -= value;2224 <FungibleItemList<T>>::insert(collection_id, owner.as_sub(), balance);2225 }22262227 Self::deposit_event(RawEvent::Transfer(collection.id, 1, owner.clone(), recipient.clone(), value));22282229 Ok(())2230 }22312232 fn transfer_refungible(2233 collection: &CollectionHandle<T>,2234 item_id: TokenId,2235 value: u128,2236 owner: T::CrossAccountId,2237 new_owner: T::CrossAccountId,2238 ) -> DispatchResult {2239 let collection_id = collection.id;2240 let full_item = <ReFungibleItemList<T>>::get(collection_id, item_id)2241 .ok_or(Error::<T>::TokenNotFound)?;22422243 let item = full_item2244 .owner2245 .iter()2246 .filter(|i| i.owner == owner)2247 .next()2248 .ok_or(Error::<T>::TokenNotFound)?;2249 let amount = item.fraction;22502251 ensure!(amount >= value, Error::<T>::TokenValueTooLow);22522253 // update balance2254 let balance_old_owner = <Balance<T>>::get(collection_id, item.owner.as_sub())2255 .checked_sub(value)2256 .ok_or(Error::<T>::NumOverflow)?;2257 <Balance<T>>::insert(collection_id, item.owner.as_sub(), balance_old_owner);22582259 let balance_new_owner = <Balance<T>>::get(collection_id, new_owner.as_sub())2260 .checked_add(value)2261 .ok_or(Error::<T>::NumOverflow)?;2262 <Balance<T>>::insert(collection_id, new_owner.as_sub(), balance_new_owner);22632264 let old_owner = item.owner.clone();2265 let new_owner_has_account = full_item.owner.iter().any(|i| i.owner == new_owner);22662267 // transfer2268 if amount == value && !new_owner_has_account {2269 // change owner2270 // new owner do not have account2271 let mut new_full_item = full_item.clone();2272 new_full_item2273 .owner2274 .iter_mut()2275 .find(|i| i.owner == owner)2276 .expect("old owner does present in refungible")2277 .owner = new_owner.clone();2278 <ReFungibleItemList<T>>::insert(collection_id, item_id, new_full_item);22792280 // update index collection2281 Self::move_token_index(collection_id, item_id, &old_owner, &new_owner)?;2282 } else {2283 let mut new_full_item = full_item.clone();2284 new_full_item2285 .owner2286 .iter_mut()2287 .find(|i| i.owner == owner)2288 .expect("old owner does present in refungible")2289 .fraction -= value;22902291 // separate amount2292 if new_owner_has_account {2293 // new owner has account2294 new_full_item2295 .owner2296 .iter_mut()2297 .find(|i| i.owner == new_owner)2298 .expect("new owner has account")2299 .fraction += value;2300 } else {2301 // new owner do not have account2302 new_full_item.owner.push(Ownership {2303 owner: new_owner.clone(),2304 fraction: value,2305 });2306 Self::add_token_index(collection_id, item_id, &new_owner)?;2307 }23082309 <ReFungibleItemList<T>>::insert(collection_id, item_id, new_full_item);2310 }23112312 Self::deposit_event(RawEvent::Transfer(collection.id, item_id, owner, new_owner, amount));23132314 Ok(())2315 }23162317 fn transfer_nft(2318 collection: &CollectionHandle<T>,2319 item_id: TokenId,2320 sender: T::CrossAccountId,2321 new_owner: T::CrossAccountId,2322 ) -> DispatchResult {2323 let collection_id = collection.id;2324 let mut item = <NftItemList<T>>::get(collection_id, item_id)2325 .ok_or(Error::<T>::TokenNotFound)?;23262327 ensure!(2328 sender == item.owner,2329 Error::<T>::MustBeTokenOwner2330 );23312332 // update balance2333 let balance_old_owner = <Balance<T>>::get(collection_id, item.owner.as_sub())2334 .checked_sub(1)2335 .ok_or(Error::<T>::NumOverflow)?;2336 <Balance<T>>::insert(collection_id, item.owner.as_sub(), balance_old_owner);23372338 let balance_new_owner = <Balance<T>>::get(collection_id, new_owner.as_sub())2339 .checked_add(1)2340 .ok_or(Error::<T>::NumOverflow)?;2341 <Balance<T>>::insert(collection_id, new_owner.as_sub(), balance_new_owner);23422343 // change owner2344 let old_owner = item.owner.clone();2345 item.owner = new_owner.clone();2346 <NftItemList<T>>::insert(collection_id, item_id, item);23472348 // update index collection2349 Self::move_token_index(collection_id, item_id, &old_owner, &new_owner)?;23502351 Self::deposit_event(RawEvent::Transfer(collection.id, item_id, sender, new_owner, 1));23522353 Ok(())2354 }2355 2356 fn set_re_fungible_variable_data(2357 collection: &CollectionHandle<T>,2358 item_id: TokenId,2359 data: Vec<u8>2360 ) -> DispatchResult {2361 let collection_id = collection.id;2362 let mut item = <ReFungibleItemList<T>>::get(collection_id, item_id)2363 .ok_or(Error::<T>::TokenNotFound)?;23642365 item.variable_data = data;23662367 <ReFungibleItemList<T>>::insert(collection_id, item_id, item);23682369 Ok(())2370 }23712372 fn set_nft_variable_data(2373 collection: &CollectionHandle<T>,2374 item_id: TokenId,2375 data: Vec<u8>2376 ) -> DispatchResult {2377 let collection_id = collection.id;2378 let mut item = <NftItemList<T>>::get(collection_id, item_id)2379 .ok_or(Error::<T>::TokenNotFound)?;2380 2381 item.variable_data = data;23822383 <NftItemList<T>>::insert(collection_id, item_id, item);2384 2385 Ok(())2386 }23872388 fn init_collection(item: &Collection<T>) {2389 // check params2390 assert!(2391 item.decimal_points <= MAX_DECIMAL_POINTS,2392 "decimal_points parameter must be lower than MAX_DECIMAL_POINTS"2393 );2394 assert!(2395 item.name.len() <= 64,2396 "Collection name can not be longer than 63 char"2397 );2398 assert!(2399 item.name.len() <= 256,2400 "Collection description can not be longer than 255 char"2401 );2402 assert!(2403 item.token_prefix.len() <= 16,2404 "Token prefix can not be longer than 15 char"2405 );24062407 // Generate next collection ID2408 let next_id = CreatedCollectionCount::get()2409 .checked_add(1)2410 .unwrap();24112412 CreatedCollectionCount::put(next_id);2413 }24142415 fn init_nft_token(collection_id: CollectionId, item: &NftItemType<T::CrossAccountId>) {2416 let current_index = <ItemListIndex>::get(collection_id)2417 .checked_add(1)2418 .unwrap();24192420 Self::add_token_index(collection_id, current_index, &item.owner).unwrap();24212422 <ItemListIndex>::insert(collection_id, current_index);24232424 // Update balance2425 let new_balance = <Balance<T>>::get(collection_id, item.owner.as_sub())2426 .checked_add(1)2427 .unwrap();2428 <Balance<T>>::insert(collection_id, item.owner.as_sub(), new_balance);2429 }24302431 fn init_fungible_token(collection_id: CollectionId, owner: &T::CrossAccountId, item: &FungibleItemType) {2432 let current_index = <ItemListIndex>::get(collection_id)2433 .checked_add(1)2434 .unwrap();24352436 Self::add_token_index(collection_id, current_index, owner).unwrap();24372438 <ItemListIndex>::insert(collection_id, current_index);24392440 // Update balance2441 let new_balance = <Balance<T>>::get(collection_id, owner.as_sub())2442 .checked_add(item.value)2443 .unwrap();2444 <Balance<T>>::insert(collection_id, owner.as_sub(), new_balance);2445 }24462447 fn init_refungible_token(collection_id: CollectionId, item: &ReFungibleItemType<T::CrossAccountId>) {2448 let current_index = <ItemListIndex>::get(collection_id)2449 .checked_add(1)2450 .unwrap();24512452 let value = item.owner.first().unwrap().fraction;2453 let owner = item.owner.first().unwrap().owner.clone();24542455 Self::add_token_index(collection_id, current_index, &owner).unwrap();24562457 <ItemListIndex>::insert(collection_id, current_index);24582459 // Update balance2460 let new_balance = <Balance<T>>::get(collection_id, &owner.as_sub())2461 .checked_add(value)2462 .unwrap();2463 <Balance<T>>::insert(collection_id, owner.as_sub(), new_balance);2464 }24652466 fn add_token_index(collection_id: CollectionId, item_index: TokenId, owner: &T::CrossAccountId) -> DispatchResult {2467 // add to account limit2468 if <AccountItemCount<T>>::contains_key(owner.as_sub()) {24692470 // bound Owned tokens by a single address2471 let count = <AccountItemCount<T>>::get(owner.as_sub());2472 ensure!(count < ChainLimit::get().account_token_ownership_limit, Error::<T>::AddressOwnershipLimitExceeded);24732474 <AccountItemCount<T>>::insert(owner.as_sub(), count2475 .checked_add(1)2476 .ok_or(Error::<T>::NumOverflow)?);2477 }2478 else {2479 <AccountItemCount<T>>::insert(owner.as_sub(), 1);2480 }24812482 let list_exists = <AddressTokens<T>>::contains_key(collection_id, owner.as_sub());2483 if list_exists {2484 let mut list = <AddressTokens<T>>::get(collection_id, owner.as_sub());2485 let item_contains = list.contains(&item_index.clone());24862487 if !item_contains {2488 list.push(item_index.clone());2489 }24902491 <AddressTokens<T>>::insert(collection_id, owner.as_sub(), list);2492 } else {2493 let mut itm = Vec::new();2494 itm.push(item_index.clone());2495 <AddressTokens<T>>::insert(collection_id, owner.as_sub(), itm);2496 }24972498 Ok(())2499 }25002501 fn remove_token_index(2502 collection_id: CollectionId,2503 item_index: TokenId,2504 owner: &T::CrossAccountId,2505 ) -> DispatchResult {25062507 // update counter2508 <AccountItemCount<T>>::insert(owner.as_sub(), 2509 <AccountItemCount<T>>::get(owner.as_sub())2510 .checked_sub(1)2511 .ok_or(Error::<T>::NumOverflow)?);251225132514 let list_exists = <AddressTokens<T>>::contains_key(collection_id, owner.as_sub());2515 if list_exists {2516 let mut list = <AddressTokens<T>>::get(collection_id, owner.as_sub());2517 let item_contains = list.contains(&item_index.clone());25182519 if item_contains {2520 list.retain(|&item| item != item_index);2521 <AddressTokens<T>>::insert(collection_id, owner.as_sub(), list);2522 }2523 }25242525 Ok(())2526 }25272528 fn move_token_index(2529 collection_id: CollectionId,2530 item_index: TokenId,2531 old_owner: &T::CrossAccountId,2532 new_owner: &T::CrossAccountId,2533 ) -> DispatchResult {2534 Self::remove_token_index(collection_id, item_index, old_owner)?;2535 Self::add_token_index(collection_id, item_index, new_owner)?;25362537 Ok(())2538 }2539 2540 fn ensure_contract_owned(account: T::AccountId, contract: &T::AccountId) -> DispatchResult {2541 ensure!(<ContractOwner<T>>::get(contract) == Some(account), Error::<T>::NoPermission);25422543 Ok(())2544 }2545}25462547////////////////////////////////////////////////////////////////////////////////////////////////////2548// Economic models2549// #region25502551/// Fee multiplier.2552pub type Multiplier = FixedU128;25532554type BalanceOf<T> = <<T as pallet_transaction_payment::Config>::OnChargeTransaction as pallet_transaction_payment::OnChargeTransaction<T>>::Balance;25552556/// Require the transactor pay for themselves and maybe include a tip to gain additional priority2557/// in the queue.2558#[derive(Encode, Decode, Clone, Eq, PartialEq)]2559pub struct ChargeTransactionPayment<T: Config>(#[codec(compact)] BalanceOf<T>);25602561impl<T: Config + Send + Sync> sp_std::fmt::Debug 2562 for ChargeTransactionPayment<T>2563{2564 #[cfg(feature = "std")]2565 fn fmt(&self, f: &mut sp_std::fmt::Formatter) -> sp_std::fmt::Result {2566 write!(f, "ChargeTransactionPayment<{:?}>", self.0)2567 }2568 #[cfg(not(feature = "std"))]2569 fn fmt(&self, _: &mut sp_std::fmt::Formatter) -> sp_std::fmt::Result {2570 Ok(())2571 }2572}25732574impl<T: Config> ChargeTransactionPayment<T>2575where2576 T::Call: Dispatchable<Info=DispatchInfo, PostInfo=PostDispatchInfo> + IsSubType<Call<T>> + IsSubType<pallet_contracts::Call<T>>,2577 BalanceOf<T>: Send + Sync + From<u64> + FixedPointOperand,2578 T::AccountId: AsRef<[u8]>,2579 T::AccountId: UncheckedFrom<T::Hash>,2580{2581 fn traditional_fee(2582 len: usize,2583 info: &DispatchInfoOf<T::Call>,2584 tip: BalanceOf<T>,2585 ) -> BalanceOf<T>2586 where2587 T::Call: Dispatchable<Info = DispatchInfo>,2588 {2589 <pallet_transaction_payment::Module<T>>::compute_fee(len as u32, info, tip)2590 }25912592 fn get_priority(len: usize, info: &DispatchInfoOf<T::Call>, final_fee: BalanceOf<T>) -> TransactionPriority {2593 let weight_saturation = T::BlockWeights::get().max_block / info.weight.max(1);2594 let max_block_length = *T::BlockLength::get().max.get(DispatchClass::Normal);2595 let len_saturation = max_block_length as u64 / (len as u64).max(1);2596 let coefficient: BalanceOf<T> = weight_saturation2597 .min(len_saturation)2598 .saturated_into::<BalanceOf<T>>();2599 final_fee2600 .saturating_mul(coefficient)2601 .saturated_into::<TransactionPriority>()2602 }26032604 fn withdraw_fee(2605 &self,2606 who: &T::AccountId,2607 call: &T::Call,2608 info: &DispatchInfoOf<T::Call>,2609 len: usize,2610 ) -> Result<2611 (2612 BalanceOf<T>,2613 <<T as pallet_transaction_payment::Config>::OnChargeTransaction as pallet_transaction_payment::OnChargeTransaction<T>>::LiquidityInfo,2614 ),2615 TransactionValidityError,2616 > {2617 let tip = self.0;26182619 let fee = Self::traditional_fee(len, info, tip);26202621 // Only mess with balances if fee is not zero.2622 if fee.is_zero() {2623 return <<T as pallet_transaction_payment::Config>::OnChargeTransaction as pallet_transaction_payment::OnChargeTransaction<T>>::withdraw_fee(who, call, info, fee, tip)2624 .map(|i| (fee, i));2625 }26262627 // Determine who is paying transaction fee based on ecnomic model2628 // Parse call to extract collection ID and access collection sponsor2629 let mut sponsor: Option<T::AccountId> = (|| match IsSubType::<Call<T>>::is_sub_type(call) {2630 Some(Call::create_item(collection_id, _owner, _properties)) => {2631 let collection = <CollectionById<T>>::get(collection_id)?;26322633 // sponsor timeout2634 let block_number = <system::Module<T>>::block_number() as T::BlockNumber;26352636 let limit = collection.limits.sponsor_transfer_timeout;2637 if <CreateItemBasket<T>>::contains_key((collection_id, &who)) {2638 let last_tx_block = <CreateItemBasket<T>>::get((collection_id, &who));2639 let limit_time = last_tx_block + limit.into();2640 if block_number <= limit_time {2641 return None;2642 }2643 }2644 <CreateItemBasket<T>>::insert((collection_id, who.clone()), block_number);26452646 // check free create limit2647 if collection.limits.sponsored_data_size >= (_properties.len() as u32) {2648 collection.sponsorship.sponsor()2649 .cloned()2650 } else {2651 None2652 }2653 }2654 Some(Call::transfer(_new_owner, collection_id, item_id, _value)) => {2655 let collection = <CollectionById<T>>::get(collection_id)?;2656 2657 let mut sponsor_transfer = false;2658 if collection.sponsorship.confirmed() {26592660 let collection_limits = collection.limits;2661 let collection_mode = collection.mode;2662 2663 // sponsor timeout2664 let block_number = <system::Module<T>>::block_number() as T::BlockNumber;2665 sponsor_transfer = match collection_mode {2666 CollectionMode::NFT => {2667 2668 // get correct limit2669 let limit: u32 = if collection_limits.sponsor_transfer_timeout > 0 {2670 collection_limits.sponsor_transfer_timeout2671 } else {2672 ChainLimit::get().nft_sponsor_transfer_timeout2673 };2674 2675 let mut sponsored = true;2676 if <NftTransferBasket<T>>::contains_key(collection_id, item_id) {2677 let last_tx_block = <NftTransferBasket<T>>::get(collection_id, item_id);2678 let limit_time = last_tx_block + limit.into();2679 if block_number <= limit_time {2680 sponsored = false;2681 }2682 }2683 if sponsored {2684 <NftTransferBasket<T>>::insert(collection_id, item_id, block_number);2685 }26862687 sponsored2688 }2689 CollectionMode::Fungible(_) => {2690 2691 // get correct limit2692 let limit: u32 = if collection_limits.sponsor_transfer_timeout > 0 {2693 collection_limits.sponsor_transfer_timeout2694 } else {2695 ChainLimit::get().fungible_sponsor_transfer_timeout2696 };2697 2698 let block_number = <system::Module<T>>::block_number() as T::BlockNumber;2699 let mut sponsored = true;2700 if <FungibleTransferBasket<T>>::contains_key(collection_id, who) {2701 let last_tx_block = <FungibleTransferBasket<T>>::get(collection_id, who);2702 let limit_time = last_tx_block + limit.into();2703 if block_number <= limit_time {2704 sponsored = false;2705 }2706 }2707 if sponsored {2708 <FungibleTransferBasket<T>>::insert(collection_id, who, block_number);2709 }27102711 sponsored2712 }2713 CollectionMode::ReFungible => {2714 2715 // get correct limit2716 let limit: u32 = if collection_limits.sponsor_transfer_timeout > 0 {2717 collection_limits.sponsor_transfer_timeout2718 } else {2719 ChainLimit::get().refungible_sponsor_transfer_timeout2720 };2721 2722 let mut sponsored = true;2723 if <ReFungibleTransferBasket<T>>::contains_key(collection_id, item_id) {2724 let last_tx_block = <ReFungibleTransferBasket<T>>::get(collection_id, item_id);2725 let limit_time = last_tx_block + limit.into();2726 if block_number <= limit_time {2727 sponsored = false;2728 }2729 }2730 if sponsored {2731 <ReFungibleTransferBasket<T>>::insert(collection_id, item_id, block_number);2732 }27332734 sponsored2735 }2736 _ => {2737 false2738 },2739 };2740 }27412742 if !sponsor_transfer {2743 None2744 } else {2745 collection.sponsorship.sponsor()2746 .cloned()2747 }2748 }27492750 Some(Call::set_variable_meta_data(collection_id, item_id, data)) => {2751 let mut sponsor_metadata_changes = false;27522753 let collection = <CollectionById<T>>::get(collection_id)?;27542755 if2756 collection.sponsorship.confirmed() &&2757 // Can't sponsor fungible collection, this tx will be rejected2758 // as invalid2759 !matches!(collection.mode, CollectionMode::Fungible(_)) &&2760 data.len() <= collection.limits.sponsored_data_size as usize2761 {2762 if let Some(rate_limit) = collection.limits.sponsored_data_rate_limit {2763 let block_number = <system::Module<T>>::block_number() as T::BlockNumber;27642765 if <VariableMetaDataBasket<T>>::get(collection_id, item_id)2766 .map(|last_block| block_number - last_block > rate_limit)2767 .unwrap_or(true) 2768 {2769 sponsor_metadata_changes = true;2770 <VariableMetaDataBasket<T>>::insert(collection_id, item_id, block_number);2771 }2772 }2773 }27742775 if !sponsor_metadata_changes {2776 None2777 } else {2778 collection.sponsorship.sponsor().cloned()2779 }2780 }27812782 _ => None,2783 })();27842785 match IsSubType::<pallet_contracts::Call<T>>::is_sub_type(call) {2786 Some(pallet_contracts::Call::call(dest, _value, _gas_limit, _data)) => {27872788 let called_contract: T::AccountId = T::Lookup::lookup((*dest).clone()).unwrap_or(T::AccountId::default());27892790 let owned_contract = <ContractOwner<T>>::get(called_contract.clone()).as_ref() == Some(who);2791 let white_list_enabled = <ContractWhiteListEnabled<T>>::contains_key(called_contract.clone());2792 2793 if !owned_contract && white_list_enabled {2794 if !<ContractWhiteList<T>>::contains_key(called_contract.clone(), who) {2795 return Err(InvalidTransaction::Call.into());2796 }2797 }2798 },2799 _ => {},2800 }28012802 // Sponsor smart contracts2803 sponsor = sponsor.or_else(|| match IsSubType::<pallet_contracts::Call<T>>::is_sub_type(call) {28042805 // On instantiation: set the contract owner2806 Some(pallet_contracts::Call::instantiate(_endowment, _gas_limit, code_hash, _data, salt)) => {28072808 let new_contract_address = <pallet_contracts::Module<T>>::contract_address(2809 &who,2810 code_hash,2811 salt,2812 );2813 <ContractOwner<T>>::insert(new_contract_address.clone(), who.clone());28142815 None2816 },28172818 // On instantiation with code: set the contract owner2819 Some(pallet_contracts::Call::instantiate_with_code(_endowment, _gas_limit, _code, _data, _salt)) => {28202821 let new_contract_address = <pallet_contracts::Module<T>>::contract_address(2822 &who,2823 &T::Hashing::hash(&_code),2824 _salt,2825 );28262827 <ContractOwner<T>>::insert(new_contract_address.clone(), who.clone());28282829 None2830 }28312832 // When the contract is called, check if the sponsoring is enabled and pay fees from contract endowment if it is2833 Some(pallet_contracts::Call::call(dest, _value, _gas_limit, _data)) => {28342835 let called_contract: T::AccountId = T::Lookup::lookup((*dest).clone()).unwrap_or(T::AccountId::default());28362837 let mut sponsor_transfer = false;2838 if <ContractSponsoringRateLimit<T>>::contains_key(called_contract.clone()) {2839 let last_tx_block = <ContractSponsorBasket<T>>::get((&called_contract, &who));2840 let block_number = <system::Module<T>>::block_number() as T::BlockNumber;2841 let rate_limit = <ContractSponsoringRateLimit<T>>::get(&called_contract);2842 let limit_time = last_tx_block + rate_limit;28432844 if block_number >= limit_time {2845 <ContractSponsorBasket<T>>::insert((called_contract.clone(), who.clone()), block_number);2846 sponsor_transfer = true;2847 }2848 } else {2849 sponsor_transfer = false;2850 }2851 2852 if sponsor_transfer {2853 if <ContractSelfSponsoring<T>>::contains_key(called_contract.clone()) {2854 if <ContractSelfSponsoring<T>>::get(called_contract.clone()) {2855 return Some(called_contract);2856 }2857 }2858 }28592860 None2861 },28622863 _ => None,2864 });28652866 let who_pays_fee = sponsor.unwrap_or_else(|| who.clone());28672868 <<T as pallet_transaction_payment::Config>::OnChargeTransaction as pallet_transaction_payment::OnChargeTransaction<T>>::withdraw_fee(&who_pays_fee, call, info, fee, tip)2869 .map(|i| (fee, i))2870 }2871}287228732874impl<T: Config + Send + Sync> SignedExtension2875 for ChargeTransactionPayment<T>2876where2877 BalanceOf<T>: Send + Sync + From<u64> + FixedPointOperand,2878 T::Call: Dispatchable<Info = DispatchInfo, PostInfo = PostDispatchInfo> + IsSubType<Call<T>> + IsSubType<pallet_contracts::Call<T>>,2879 T::AccountId: AsRef<[u8]>,2880 T::AccountId: UncheckedFrom<T::Hash>,2881{2882 const IDENTIFIER: &'static str = "ChargeTransactionPayment";2883 type AccountId = T::AccountId;2884 type Call = T::Call;2885 type AdditionalSigned = ();2886 type Pre = (2887 // tip2888 BalanceOf<T>,2889 // who pays fee2890 Self::AccountId,2891 // imbalance resulting from withdrawing the fee2892 <<T as pallet_transaction_payment::Config>::OnChargeTransaction as pallet_transaction_payment::OnChargeTransaction<T>>::LiquidityInfo,2893 );2894 fn additional_signed(&self) -> sp_std::result::Result<(), TransactionValidityError> {2895 Ok(())2896 }28972898 fn validate(2899 &self,2900 who: &Self::AccountId,2901 call: &Self::Call,2902 info: &DispatchInfoOf<Self::Call>,2903 len: usize,2904 ) -> TransactionValidity {2905 let (fee, _) = self.withdraw_fee(who, call, info, len)?;2906 Ok(ValidTransaction {2907 priority: Self::get_priority(len, info, fee),2908 ..Default::default()2909 })2910 }29112912 fn pre_dispatch(2913 self,2914 who: &Self::AccountId,2915 call: &Self::Call,2916 info: &DispatchInfoOf<Self::Call>,2917 len: usize,2918 ) -> Result<Self::Pre, TransactionValidityError> {2919 let (_fee, imbalance) = self.withdraw_fee(who, call, info, len)?;2920 Ok((self.0, who.clone(), imbalance))2921 }29222923 fn post_dispatch(2924 pre: Self::Pre,2925 info: &DispatchInfoOf<Self::Call>,2926 post_info: &PostDispatchInfoOf<Self::Call>,2927 len: usize,2928 _result: &DispatchResult,2929 ) -> Result<(), TransactionValidityError> {2930 let (tip, who, imbalance) = pre;2931 let actual_fee = pallet_transaction_payment::Module::<T>::compute_actual_fee(2932 len as u32,2933 info,2934 post_info,2935 tip,2936 );2937 <T as pallet_transaction_payment::Config>::OnChargeTransaction::correct_and_deposit_fee(&who, info, post_info, actual_fee, tip, imbalance)?;2938 Ok(())2939 }2940}29412942// #endregion29432944sp_api::decl_runtime_apis! {2945 pub trait NftApi {2946 /// Used for ethereum integration2947 fn eth_contract_code(account: H160) -> Option<Vec<u8>>;2948 }2949}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)]910#[cfg(feature = "std")]11pub use serde::*;1213use core::ops::{Deref, DerefMut};14use codec::{Decode, Encode};15pub use frame_support::{16 construct_runtime, decl_event, decl_module, decl_storage, decl_error,17 dispatch::DispatchResult,18 ensure, fail, parameter_types,19 traits::{20 Currency, ExistenceRequirement, Get, Imbalance, KeyOwnerProofSystem, OnUnbalanced,21 Randomness, IsSubType, WithdrawReasons,22 },23 weights::{24 constants::{BlockExecutionWeight, ExtrinsicBaseWeight, RocksDbWeight, WEIGHT_PER_SECOND},25 DispatchInfo, GetDispatchInfo, IdentityFee, Pays, PostDispatchInfo, Weight,26 WeightToFeePolynomial, DispatchClass,27 },28 StorageValue,29 transactional,30};3132use frame_system::{self as system, ensure_signed, ensure_root};33use sp_core::{H160, H256};34use sp_runtime::sp_std::prelude::Vec;35use sp_runtime::{36 traits::{37 Hash, DispatchInfoOf, Dispatchable, PostDispatchInfoOf, Saturating, SaturatedConversion, SignedExtension, Zero,38 },39 transaction_validity::{40 TransactionPriority, InvalidTransaction, TransactionValidity, TransactionValidityError, ValidTransaction,41 },42 FixedPointOperand, FixedU128,43};44use sp_runtime::traits::StaticLookup;45use pallet_contracts::chain_extension::UncheckedFrom;46use pallet_ethereum::EthereumTransactionSender;47use pallet_transaction_payment::OnChargeTransaction;4849#[cfg(test)]50mod mock;5152#[cfg(test)]53mod tests;5455mod default_weights;56mod eth;5758pub use eth::account::*;5960pub const MAX_DECIMAL_POINTS: DecimalPoints = 30;61pub const MAX_REFUNGIBLE_PIECES: u128 = 1_000_000_000_000_000_000_000;62pub const MAX_SPONSOR_TIMEOUT: u32 = 10_368_000;63pub const MAX_TOKEN_OWNERSHIP: u32 = 10_000_000;6465// Structs66// #region6768pub type CollectionId = u32;69pub type TokenId = u32;70pub type DecimalPoints = u8;7172#[derive(Encode, Decode, Eq, Debug, Clone, PartialEq)]73#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]74pub enum CollectionMode {75 Invalid,76 NFT,77 // decimal points78 Fungible(DecimalPoints),79 ReFungible,80}8182impl Default for CollectionMode {83 fn default() -> Self {84 Self::Invalid85 }86}8788impl Into<u8> for CollectionMode {89 fn into(self) -> u8 {90 match self {91 CollectionMode::Invalid => 0,92 CollectionMode::NFT => 1,93 CollectionMode::Fungible(_) => 2,94 CollectionMode::ReFungible => 3,95 }96 }97}9899#[derive(Encode, Decode, Eq, Debug, Clone, PartialEq)]100#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]101pub enum AccessMode {102 Normal,103 WhiteList,104}105impl Default for AccessMode {106 fn default() -> Self {107 Self::Normal108 }109}110111#[derive(Encode, Decode, Eq, Debug, Clone, PartialEq)]112#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]113pub enum SchemaVersion {114 ImageURL,115 Unique,116}117impl Default for SchemaVersion {118 fn default() -> Self {119 Self::ImageURL120 }121}122123#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]124#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]125pub struct Ownership<AccountId> {126 pub owner: AccountId,127 pub fraction: u128,128}129130#[derive(Encode, Decode, Debug, Clone, PartialEq)]131#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]132pub enum SponsorshipState<AccountId> {133 /// The fees are applied to the transaction sender134 Disabled,135 Unconfirmed(AccountId),136 /// Transactions are sponsored by specified account137 Confirmed(AccountId),138}139140impl<AccountId> SponsorshipState<AccountId> {141 fn sponsor(&self) -> Option<&AccountId> {142 match self {143 Self::Confirmed(sponsor) => Some(sponsor),144 _ => None,145 }146 }147148 fn pending_sponsor(&self) -> Option<&AccountId> {149 match self {150 Self::Unconfirmed(sponsor) | Self::Confirmed(sponsor) => Some(sponsor),151 _ => None,152 }153 }154155 fn confirmed(&self) -> bool {156 matches!(self, Self::Confirmed(_))157 }158}159160impl<T> Default for SponsorshipState<T> {161 fn default() -> Self {162 Self::Disabled163 }164}165166#[derive(Encode, Decode, Clone, PartialEq)]167#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]168pub struct Collection<T: Config> {169 pub owner: T::CrossAccountId,170 pub mode: CollectionMode,171 pub access: AccessMode,172 pub decimal_points: DecimalPoints,173 pub name: Vec<u16>, // 64 include null escape char174 pub description: Vec<u16>, // 256 include null escape char175 pub token_prefix: Vec<u8>, // 16 include null escape char176 pub mint_mode: bool,177 pub offchain_schema: Vec<u8>,178 pub schema_version: SchemaVersion,179 pub sponsorship: SponsorshipState<T::AccountId>,180 pub limits: CollectionLimits<T::BlockNumber>, // Collection private restrictions 181 pub variable_on_chain_schema: Vec<u8>, //182 pub const_on_chain_schema: Vec<u8>, //183}184185pub struct CollectionHandle<T: Config> {186 pub id: CollectionId,187 collection: Collection<T>,188 logs: eth::log::LogRecorder,189}190impl<T: Config> CollectionHandle<T> {191 pub fn get(id: CollectionId) -> Option<Self> {192 <CollectionById<T>>::get(id)193 .map(|collection| Self {194 id,195 collection,196 logs: eth::log::LogRecorder::default(),197 })198 }199 pub fn log(&self, topics: Vec<H256>, data: eth::abi::AbiWriter) {200 self.logs.log(topics, data)201 }202 pub fn into_inner(self) -> Collection<T> {203 self.collection.clone()204 }205}206207impl<T: Config> Deref for CollectionHandle<T> {208 type Target = Collection<T>;209210 fn deref(&self) -> &Self::Target {211 &self.collection212 }213}214215impl<T: Config> DerefMut for CollectionHandle<T> {216 fn deref_mut(&mut self) -> &mut Self::Target {217 &mut self.collection218 }219}220221#[derive(Encode, Decode, Debug, Clone, PartialEq)]222#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]223pub struct NftItemType<AccountId> {224 pub owner: AccountId,225 pub const_data: Vec<u8>,226 pub variable_data: Vec<u8>,227}228229#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]230#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]231pub struct FungibleItemType {232 pub value: u128,233}234235#[derive(Encode, Decode, Debug, Clone, PartialEq)]236#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]237pub struct ReFungibleItemType<AccountId> {238 pub owner: Vec<Ownership<AccountId>>,239 pub const_data: Vec<u8>,240 pub variable_data: Vec<u8>,241}242243// #[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]244// #[cfg_attr(feature = "std", derive(Serialize, Deserialize))]245// pub struct VestingItem<AccountId, Moment> {246// pub sender: AccountId,247// pub recipient: AccountId,248// pub collection_id: CollectionId,249// pub item_id: TokenId,250// pub amount: u64,251// pub vesting_date: Moment,252// }253254#[derive(Encode, Decode, Debug, Clone, PartialEq)]255#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]256pub struct CollectionLimits<BlockNumber: Encode + Decode> {257 pub account_token_ownership_limit: u32,258 pub sponsored_data_size: u32,259 /// None - setVariableMetadata is not sponsored260 /// Some(v) - setVariableMetadata is sponsored 261 /// if there is v block between txs262 pub sponsored_data_rate_limit: Option<BlockNumber>,263 pub token_limit: u32,264265 // Timeouts for item types in passed blocks266 pub sponsor_transfer_timeout: u32,267 pub owner_can_transfer: bool,268 pub owner_can_destroy: bool,269}270271impl<BlockNumber: Encode + Decode> Default for CollectionLimits<BlockNumber> {272 fn default() -> Self {273 Self { 274 account_token_ownership_limit: 10_000_000, 275 token_limit: u32::max_value(),276 sponsored_data_size: u32::MAX, 277 sponsored_data_rate_limit: None,278 sponsor_transfer_timeout: 14400,279 owner_can_transfer: true,280 owner_can_destroy: true281 }282 }283}284285#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]286#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]287pub struct ChainLimits {288 pub collection_numbers_limit: u32,289 pub account_token_ownership_limit: u32,290 pub collections_admins_limit: u64,291 pub custom_data_limit: u32,292293 // Timeouts for item types in passed blocks294 pub nft_sponsor_transfer_timeout: u32,295 pub fungible_sponsor_transfer_timeout: u32,296 pub refungible_sponsor_transfer_timeout: u32,297298 // Schema limits299 pub offchain_schema_limit: u32,300 pub variable_on_chain_schema_limit: u32,301 pub const_on_chain_schema_limit: u32,302}303304pub trait WeightInfo {305 fn create_collection() -> Weight;306 fn destroy_collection() -> Weight;307 fn add_to_white_list() -> Weight;308 fn remove_from_white_list() -> Weight;309 fn set_public_access_mode() -> Weight;310 fn set_mint_permission() -> Weight;311 fn change_collection_owner() -> Weight;312 fn add_collection_admin() -> Weight;313 fn remove_collection_admin() -> Weight;314 fn set_collection_sponsor() -> Weight;315 fn confirm_sponsorship() -> Weight;316 fn remove_collection_sponsor() -> Weight;317 fn create_item(s: usize) -> Weight;318 fn burn_item() -> Weight;319 fn transfer() -> Weight;320 fn approve() -> Weight;321 fn transfer_from() -> Weight;322 fn set_offchain_schema() -> Weight;323 fn set_const_on_chain_schema() -> Weight;324 fn set_variable_on_chain_schema() -> Weight;325 fn set_variable_meta_data() -> Weight;326 fn enable_contract_sponsoring() -> Weight;327 fn set_schema_version() -> Weight;328 fn set_chain_limits() -> Weight;329 fn set_contract_sponsoring_rate_limit() -> Weight;330 fn set_variable_meta_data_sponsoring_rate_limit() -> Weight;331 fn toggle_contract_white_list() -> Weight;332 fn add_to_contract_white_list() -> Weight;333 fn remove_from_contract_white_list() -> Weight;334 fn set_collection_limits() -> Weight;335}336337#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]338#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]339pub struct CreateNftData {340 pub const_data: Vec<u8>,341 pub variable_data: Vec<u8>,342}343344#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]345#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]346pub struct CreateFungibleData {347 pub value: u128,348}349350#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]351#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]352pub struct CreateReFungibleData {353 pub const_data: Vec<u8>,354 pub variable_data: Vec<u8>,355 pub pieces: u128,356}357358#[derive(Encode, Decode, Debug, Clone, PartialEq)]359#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]360pub enum CreateItemData {361 NFT(CreateNftData),362 Fungible(CreateFungibleData),363 ReFungible(CreateReFungibleData),364}365366impl CreateItemData {367 pub fn len(&self) -> usize {368 let len = match self {369 CreateItemData::NFT(data) => data.variable_data.len() + data.const_data.len(),370 CreateItemData::ReFungible(data) => data.variable_data.len() + data.const_data.len(),371 _ => 0372 };373 374 return len;375 }376}377378impl From<CreateNftData> for CreateItemData {379 fn from(item: CreateNftData) -> Self {380 CreateItemData::NFT(item)381 }382}383384impl From<CreateReFungibleData> for CreateItemData {385 fn from(item: CreateReFungibleData) -> Self {386 CreateItemData::ReFungible(item)387 }388}389390impl From<CreateFungibleData> for CreateItemData {391 fn from(item: CreateFungibleData) -> Self {392 CreateItemData::Fungible(item)393 }394}395396397decl_error! {398 /// Error for non-fungible-token module.399 pub enum Error for Module<T: Config> {400 /// Total collections bound exceeded.401 TotalCollectionsLimitExceeded,402 /// Decimal_points parameter must be lower than MAX_DECIMAL_POINTS constant, currently it is 30.403 CollectionDecimalPointLimitExceeded, 404 /// Collection name can not be longer than 63 char.405 CollectionNameLimitExceeded, 406 /// Collection description can not be longer than 255 char.407 CollectionDescriptionLimitExceeded, 408 /// Token prefix can not be longer than 15 char.409 CollectionTokenPrefixLimitExceeded,410 /// This collection does not exist.411 CollectionNotFound,412 /// Item not exists.413 TokenNotFound,414 /// Admin not found415 AdminNotFound,416 /// Arithmetic calculation overflow.417 NumOverflow, 418 /// Account already has admin role.419 AlreadyAdmin, 420 /// You do not own this collection.421 NoPermission,422 /// This address is not set as sponsor, use setCollectionSponsor first.423 ConfirmUnsetSponsorFail,424 /// Collection is not in mint mode.425 PublicMintingNotAllowed,426 /// Sender parameter and item owner must be equal.427 MustBeTokenOwner,428 /// Item balance not enough.429 TokenValueTooLow,430 /// Size of item is too large.431 NftSizeLimitExceeded,432 /// No approve found433 ApproveNotFound,434 /// Requested value more than approved.435 TokenValueNotEnough,436 /// Only approved addresses can call this method.437 ApproveRequired,438 /// Address is not in white list.439 AddresNotInWhiteList,440 /// Number of collection admins bound exceeded.441 CollectionAdminsLimitExceeded,442 /// Owned tokens by a single address bound exceeded.443 AddressOwnershipLimitExceeded,444 /// Length of items properties must be greater than 0.445 EmptyArgument,446 /// const_data exceeded data limit.447 TokenConstDataLimitExceeded,448 /// variable_data exceeded data limit.449 TokenVariableDataLimitExceeded,450 /// Not NFT item data used to mint in NFT collection.451 NotNftDataUsedToMintNftCollectionToken,452 /// Not Fungible item data used to mint in Fungible collection.453 NotFungibleDataUsedToMintFungibleCollectionToken,454 /// Not Re Fungible item data used to mint in Re Fungible collection.455 NotReFungibleDataUsedToMintReFungibleCollectionToken,456 /// Unexpected collection type.457 UnexpectedCollectionType,458 /// Can't store metadata in fungible tokens.459 CantStoreMetadataInFungibleTokens,460 /// Collection token limit exceeded461 CollectionTokenLimitExceeded,462 /// Account token limit exceeded per collection463 AccountTokenLimitExceeded,464 /// Collection limit bounds per collection exceeded465 CollectionLimitBoundsExceeded,466 /// Tried to enable permissions which are only permitted to be disabled467 OwnerPermissionsCantBeReverted,468 /// Schema data size limit bound exceeded469 SchemaDataLimitExceeded,470 /// Maximum refungibility exceeded471 WrongRefungiblePieces,472 /// createRefungible should be called with one owner473 BadCreateRefungibleCall,474 }475}476477pub trait Config: system::Config + Sized + pallet_transaction_payment::Config + pallet_contracts::Config {478 type Event: From<Event<Self>> + Into<<Self as system::Config>::Event>;479480 /// Weight information for extrinsics in this pallet.481 type WeightInfo: WeightInfo;482483 type EvmAddressMapping: pallet_evm::AddressMapping<Self::AccountId>;484 type EvmBackwardsAddressMapping: EvmBackwardsAddressMapping<Self::AccountId>;485 type EvmWithdrawOrigin: pallet_evm::EnsureAddressOrigin<Self::Origin, Success = Self::AccountId>;486487 type CrossAccountId: CrossAccountId<Self::AccountId>;488 type Currency: Currency<Self::AccountId>;489 type CollectionCreationPrice: Get<<<Self as Config>::Currency as Currency<Self::AccountId>>::Balance>;490 type TreasuryAccountId: Get<Self::AccountId>;491492 type EthereumChainId: Get<u64>;493 type EthereumTransactionSender: pallet_ethereum::EthereumTransactionSender;494}495496#[cfg(feature = "runtime-benchmarks")]497mod benchmarking;498499// #endregion500501// # Used definitions502//503// ## User control levels504//505// chain-controlled - key is uncontrolled by user506// i.e autoincrementing index507// can use non-cryptographic hash508// real - key is controlled by user509// but it is hard to generate enough colliding values, i.e owner of signed txs510// can use non-cryptographic hash511// controlled - key is completly controlled by users512// i.e maps with mutable keys513// should use cryptographic hash514//515// ## User control level downgrade reasons516//517// ?1 - chain-controlled -> controlled518// collections/tokens can be destroyed, resulting in massive holes519// ?2 - chain-controlled -> controlled520// same as ?1, but can be only added, resulting in easier exploitation521// ?3 - real -> controlled522// no confirmation required, so addresses can be easily generated523decl_storage! {524 trait Store for Module<T: Config> as Nft {525526 //#region Private members527 /// Id of next collection528 CreatedCollectionCount: u32;529 /// Used for migrations530 ChainVersion: u64;531 /// Id of last collection token532 /// Collection id (controlled?1)533 ItemListIndex: map hasher(blake2_128_concat) CollectionId => TokenId;534 //#endregion535536 //#region Chain limits struct537 pub ChainLimit get(fn chain_limit) config(): ChainLimits;538 //#endregion539540 //#region Bound counters541 /// Amount of collections destroyed, used for total amount tracking with542 /// CreatedCollectionCount543 DestroyedCollectionCount: u32;544 /// Total amount of account owned tokens (NFTs + RFTs + unique fungibles)545 /// Account id (real)546 pub AccountItemCount get(fn account_item_count): map hasher(twox_64_concat) T::AccountId => u32;547 //#endregion548549 //#region Basic collections550 /// Collection info551 /// Collection id (controlled?1)552 pub CollectionById get(fn collection_id) config(): map hasher(blake2_128_concat) CollectionId => Option<Collection<T>> = None;553 /// List of collection admins554 /// Collection id (controlled?2)555 pub AdminList get(fn admin_list_collection): map hasher(blake2_128_concat) CollectionId => Vec<T::CrossAccountId>;556 /// Whitelisted collection users557 /// Collection id (controlled?2), user id (controlled?3)558 pub WhiteList get(fn white_list): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) T::AccountId => bool;559 //#endregion560561 /// How many of collection items user have562 /// Collection id (controlled?2), account id (real)563 pub Balance get(fn balance_count): double_map hasher(blake2_128_concat) CollectionId, hasher(twox_64_concat) T::AccountId => u128;564565 /// Amount of items which spender can transfer out of owners account (via transferFrom)566 /// Collection id (controlled?2), (token id (controlled ?2) + owner account id (real) + spender account id (controlled?3))567 /// TODO: Off chain worker should remove from this map when token gets removed568 pub Allowances get(fn approved): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) (TokenId, T::AccountId, T::AccountId) => u128;569570 //#region Item collections571 /// Collection id (controlled?2), token id (controlled?1)572 pub NftItemList get(fn nft_item_id) config(): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => Option<NftItemType<T::CrossAccountId>>;573 /// Collection id (controlled?2), owner (controlled?2)574 pub FungibleItemList get(fn fungible_item_id) config(): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) T::AccountId => FungibleItemType;575 /// Collection id (controlled?2), token id (controlled?1)576 pub ReFungibleItemList get(fn refungible_item_id) config(): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => Option<ReFungibleItemType<T::CrossAccountId>>;577 //#endregion578579 //#region Index list580 /// Collection id (controlled?2), tokens owner (controlled?2)581 pub AddressTokens get(fn address_tokens): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) T::AccountId => Vec<TokenId>;582 //#endregion583584 //#region Tokens transfer rate limit baskets585 /// (Collection id (controlled?2), who created (real))586 /// TODO: Off chain worker should remove from this map when collection gets removed587 pub CreateItemBasket get(fn create_item_basket): map hasher(blake2_128_concat) (CollectionId, T::AccountId) => T::BlockNumber;588 /// Collection id (controlled?2), token id (controlled?2)589 pub NftTransferBasket get(fn nft_transfer_basket): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => T::BlockNumber;590 /// Collection id (controlled?2), owning user (real)591 pub FungibleTransferBasket get(fn fungible_transfer_basket): double_map hasher(blake2_128_concat) CollectionId, hasher(twox_64_concat) T::AccountId => T::BlockNumber;592 /// Collection id (controlled?2), token id (controlled?2)593 pub ReFungibleTransferBasket get(fn refungible_transfer_basket): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => T::BlockNumber;594 //#endregion595596 /// Variable metadata sponsoring597 /// Collection id (controlled?2), token id (controlled?2)598 pub VariableMetaDataBasket get(fn variable_meta_data_basket): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => Option<T::BlockNumber> = None;599 600 //#region Contract Sponsorship and Ownership601 /// Contract address (real)602 pub ContractOwner get(fn contract_owner): map hasher(twox_64_concat) T::AccountId => Option<T::AccountId>;603 /// Contract address (real)604 pub ContractSelfSponsoring get(fn contract_self_sponsoring): map hasher(twox_64_concat) T::AccountId => bool;605 /// (Contract address(real), caller (real))606 pub ContractSponsorBasket get(fn contract_sponsor_basket): map hasher(twox_64_concat) (T::AccountId, T::AccountId) => T::BlockNumber;607 /// Contract address (real)608 pub ContractSponsoringRateLimit get(fn contract_sponsoring_rate_limit): map hasher(twox_64_concat) T::AccountId => T::BlockNumber;609 /// Contract address (real)610 pub ContractWhiteListEnabled get(fn contract_white_list_enabled): map hasher(twox_64_concat) T::AccountId => bool; 611 /// Contract address (real) => Whitelisted user (controlled?3)612 pub ContractWhiteList get(fn contract_white_list): double_map hasher(twox_64_concat) T::AccountId, hasher(blake2_128_concat) T::AccountId => bool; 613 //#endregion614 }615 add_extra_genesis {616 build(|config: &GenesisConfig<T>| {617 // Modification of storage618 for (_num, _c) in &config.collection_id {619 <Module<T>>::init_collection(_c);620 }621622 for (_num, _c, _i) in &config.nft_item_id {623 <Module<T>>::init_nft_token(*_c, _i);624 }625626 for (collection_id, account_id, fungible_item) in &config.fungible_item_id {627 <Module<T>>::init_fungible_token(*collection_id, &T::CrossAccountId::from_sub(account_id.clone()), fungible_item);628 }629630 for (_num, _c, _i) in &config.refungible_item_id {631 <Module<T>>::init_refungible_token(*_c, _i);632 }633 })634 }635}636637decl_event!(638 pub enum Event<T>639 where640 CrossAccountId = <T as Config>::CrossAccountId,641 {642 /// New collection was created643 /// 644 /// # Arguments645 /// 646 /// * collection_id: Globally unique identifier of newly created collection.647 /// 648 /// * mode: [CollectionMode] converted into u8.649 /// 650 /// * account_id: Collection owner.651 CollectionCreated(CollectionId, u8, CrossAccountId),652653 /// New item was created.654 /// 655 /// # Arguments656 /// 657 /// * collection_id: Id of the collection where item was created.658 /// 659 /// * item_id: Id of an item. Unique within the collection.660 ///661 /// * recipient: Owner of newly created item 662 ItemCreated(CollectionId, TokenId, CrossAccountId),663664 /// Collection item was burned.665 /// 666 /// # Arguments667 /// 668 /// collection_id.669 /// 670 /// item_id: Identifier of burned NFT.671 ItemDestroyed(CollectionId, TokenId),672673 /// Item was transferred674 ///675 /// * collection_id: Id of collection to which item is belong676 ///677 /// * item_id: Id of an item678 ///679 /// * sender: Original owner of item680 ///681 /// * recipient: New owner of item682 ///683 /// * amount: Always 1 for NFT684 Transfer(CollectionId, TokenId, CrossAccountId, CrossAccountId, u128),685686 /// * collection_id687 ///688 /// * item_id689 ///690 /// * sender691 ///692 /// * spender693 ///694 /// * amount695 Approved(CollectionId, TokenId, CrossAccountId, CrossAccountId, u128),696 }697);698699decl_module! {700 pub struct Module<T: Config> for enum Call 701 where 702 origin: T::Origin703 {704 fn deposit_event() = default;705 type Error = Error<T>;706707 fn on_initialize(now: T::BlockNumber) -> Weight {708 0709 }710711 /// 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.712 /// 713 /// # Permissions714 /// 715 /// * Anyone.716 /// 717 /// # Arguments718 /// 719 /// * collection_name: UTF-16 string with collection name (limit 64 characters), will be stored as zero-terminated.720 /// 721 /// * collection_description: UTF-16 string with collection description (limit 256 characters), will be stored as zero-terminated.722 /// 723 /// * token_prefix: UTF-8 string with token prefix.724 /// 725 /// * mode: [CollectionMode] collection type and type dependent data.726 // returns collection ID727 #[weight = <T as Config>::WeightInfo::create_collection()]728 #[transactional]729 pub fn create_collection(origin,730 collection_name: Vec<u16>,731 collection_description: Vec<u16>,732 token_prefix: Vec<u8>,733 mode: CollectionMode) -> DispatchResult {734735 // Anyone can create a collection736 let who = T::CrossAccountId::from_sub(ensure_signed(origin)?);737738 // Take a (non-refundable) deposit of collection creation739 let mut imbalance = <<<T as Config>::Currency as Currency<T::AccountId>>::PositiveImbalance>::zero();740 imbalance.subsume(<<T as Config>::Currency as Currency<T::AccountId>>::deposit_creating(741 &T::TreasuryAccountId::get(),742 T::CollectionCreationPrice::get(),743 ));744 <T as Config>::Currency::settle(745 who.as_sub(),746 imbalance,747 WithdrawReasons::TRANSFER,748 ExistenceRequirement::KeepAlive,749 ).map_err(|_| Error::<T>::NoPermission)?;750751 let decimal_points = match mode {752 CollectionMode::Fungible(points) => points,753 _ => 0754 };755756 let chain_limit = ChainLimit::get();757758 let created_count = CreatedCollectionCount::get();759 let destroyed_count = DestroyedCollectionCount::get();760761 // bound Total number of collections762 ensure!(created_count - destroyed_count < chain_limit.collection_numbers_limit, Error::<T>::TotalCollectionsLimitExceeded);763764 // check params765 ensure!(decimal_points <= MAX_DECIMAL_POINTS, Error::<T>::CollectionDecimalPointLimitExceeded);766 ensure!(collection_name.len() <= 64, Error::<T>::CollectionNameLimitExceeded);767 ensure!(collection_description.len() <= 256, Error::<T>::CollectionDescriptionLimitExceeded);768 ensure!(token_prefix.len() <= 16, Error::<T>::CollectionTokenPrefixLimitExceeded);769770 // Generate next collection ID771 let next_id = created_count772 .checked_add(1)773 .ok_or(Error::<T>::NumOverflow)?;774775 CreatedCollectionCount::put(next_id);776777 let limits = CollectionLimits {778 sponsored_data_size: chain_limit.custom_data_limit,779 ..Default::default()780 };781782 // Create new collection783 let new_collection = Collection {784 owner: who.clone(),785 name: collection_name,786 mode: mode.clone(),787 mint_mode: false,788 access: AccessMode::Normal,789 description: collection_description,790 decimal_points: decimal_points,791 token_prefix: token_prefix,792 offchain_schema: Vec::new(),793 schema_version: SchemaVersion::ImageURL,794 sponsorship: SponsorshipState::Disabled,795 variable_on_chain_schema: Vec::new(),796 const_on_chain_schema: Vec::new(),797 limits,798 };799800 // Add new collection to map801 <CollectionById<T>>::insert(next_id, new_collection);802803 // call event804 Self::deposit_event(RawEvent::CollectionCreated(next_id, mode.into(), who));805806 Ok(())807 }808809 /// **DANGEROUS**: Destroys collection and all NFTs within this collection. Users irrecoverably lose their assets and may lose real money.810 /// 811 /// # Permissions812 /// 813 /// * Collection Owner.814 /// 815 /// # Arguments816 /// 817 /// * collection_id: collection to destroy.818 #[weight = <T as Config>::WeightInfo::destroy_collection()]819 #[transactional]820 pub fn destroy_collection(origin, collection_id: CollectionId) -> DispatchResult {821822 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);823 let collection = Self::get_collection(collection_id)?;824 Self::check_owner_permissions(&collection, &sender)?;825 if !collection.limits.owner_can_destroy {826 fail!(Error::<T>::NoPermission);827 }828829 <AddressTokens<T>>::remove_prefix(collection_id);830 <Allowances<T>>::remove_prefix(collection_id);831 <Balance<T>>::remove_prefix(collection_id);832 <ItemListIndex>::remove(collection_id);833 <AdminList<T>>::remove(collection_id);834 <CollectionById<T>>::remove(collection_id);835 <WhiteList<T>>::remove_prefix(collection_id);836837 <NftItemList<T>>::remove_prefix(collection_id);838 <FungibleItemList<T>>::remove_prefix(collection_id);839 <ReFungibleItemList<T>>::remove_prefix(collection_id);840841 <NftTransferBasket<T>>::remove_prefix(collection_id);842 <FungibleTransferBasket<T>>::remove_prefix(collection_id);843 <ReFungibleTransferBasket<T>>::remove_prefix(collection_id);844845 <VariableMetaDataBasket<T>>::remove_prefix(collection_id);846847 DestroyedCollectionCount::put(DestroyedCollectionCount::get()848 .checked_add(1)849 .ok_or(Error::<T>::NumOverflow)?);850851 Ok(())852 }853854 /// Add an address to white list.855 /// 856 /// # Permissions857 /// 858 /// * Collection Owner859 /// * Collection Admin860 /// 861 /// # Arguments862 /// 863 /// * collection_id.864 /// 865 /// * address.866 #[weight = <T as Config>::WeightInfo::add_to_white_list()]867 #[transactional]868 pub fn add_to_white_list(origin, collection_id: CollectionId, address: T::CrossAccountId) -> DispatchResult{869870 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);871 let collection = Self::get_collection(collection_id)?;872 Self::check_owner_or_admin_permissions(&collection, &sender)?;873874 <WhiteList<T>>::insert(collection_id, address.as_sub(), true);875 876 Ok(())877 }878879 /// Remove an address from white list.880 /// 881 /// # Permissions882 /// 883 /// * Collection Owner884 /// * Collection Admin885 /// 886 /// # Arguments887 /// 888 /// * collection_id.889 /// 890 /// * address.891 #[weight = <T as Config>::WeightInfo::remove_from_white_list()]892 #[transactional]893 pub fn remove_from_white_list(origin, collection_id: CollectionId, address: T::CrossAccountId) -> DispatchResult{894895 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);896 let collection = Self::get_collection(collection_id)?;897 Self::check_owner_or_admin_permissions(&collection, &sender)?;898899 <WhiteList<T>>::remove(collection_id, address.as_sub());900901 Ok(())902 }903904 /// Toggle between normal and white list access for the methods with access for `Anyone`.905 /// 906 /// # Permissions907 /// 908 /// * Collection Owner.909 /// 910 /// # Arguments911 /// 912 /// * collection_id.913 /// 914 /// * mode: [AccessMode]915 #[weight = <T as Config>::WeightInfo::set_public_access_mode()]916 #[transactional]917 pub fn set_public_access_mode(origin, collection_id: CollectionId, mode: AccessMode) -> DispatchResult918 {919 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);920921 let mut target_collection = Self::get_collection(collection_id)?;922 Self::check_owner_permissions(&target_collection, &sender)?;923 target_collection.access = mode;924 Self::save_collection(target_collection);925926 Ok(())927 }928929 /// Allows Anyone to create tokens if:930 /// * White List is enabled, and931 /// * Address is added to white list, and932 /// * This method was called with True parameter933 /// 934 /// # Permissions935 /// * Collection Owner936 ///937 /// # Arguments938 /// 939 /// * collection_id.940 /// 941 /// * mint_permission: Boolean parameter. If True, allows minting to Anyone with conditions above.942 #[weight = <T as Config>::WeightInfo::set_mint_permission()]943 #[transactional]944 pub fn set_mint_permission(origin, collection_id: CollectionId, mint_permission: bool) -> DispatchResult945 {946 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);947948 let mut target_collection = Self::get_collection(collection_id)?;949 Self::check_owner_permissions(&target_collection, &sender)?;950 target_collection.mint_mode = mint_permission;951 Self::save_collection(target_collection);952953 Ok(())954 }955956 /// Change the owner of the collection.957 /// 958 /// # Permissions959 /// 960 /// * Collection Owner.961 /// 962 /// # Arguments963 /// 964 /// * collection_id.965 /// 966 /// * new_owner.967 #[weight = <T as Config>::WeightInfo::change_collection_owner()]968 #[transactional]969 pub fn change_collection_owner(origin, collection_id: CollectionId, new_owner: T::CrossAccountId) -> DispatchResult {970971 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);972 let mut target_collection = Self::get_collection(collection_id)?;973 Self::check_owner_permissions(&target_collection, &sender)?;974 target_collection.owner = new_owner;975 Self::save_collection(target_collection);976977 Ok(())978 }979980 /// Adds an admin of the Collection.981 /// 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. 982 /// 983 /// # Permissions984 /// 985 /// * Collection Owner.986 /// * Collection Admin.987 /// 988 /// # Arguments989 /// 990 /// * collection_id: ID of the Collection to add admin for.991 /// 992 /// * new_admin_id: Address of new admin to add.993 #[weight = <T as Config>::WeightInfo::add_collection_admin()]994 #[transactional]995 pub fn add_collection_admin(origin, collection_id: CollectionId, new_admin_id: T::CrossAccountId) -> DispatchResult {996 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);997 let collection = Self::get_collection(collection_id)?;998 Self::check_owner_or_admin_permissions(&collection, &sender)?;999 let mut admin_arr = <AdminList<T>>::get(collection_id);10001001 match admin_arr.binary_search(&new_admin_id) {1002 Ok(_) => {},1003 Err(idx) => {1004 let limits = ChainLimit::get();1005 ensure!(admin_arr.len() < limits.collections_admins_limit as usize, Error::<T>::CollectionAdminsLimitExceeded);1006 admin_arr.insert(idx, new_admin_id);1007 <AdminList<T>>::insert(collection_id, admin_arr);1008 }1009 }1010 Ok(())1011 }10121013 /// 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.1014 ///1015 /// # Permissions1016 /// 1017 /// * Collection Owner.1018 /// * Collection Admin.1019 /// 1020 /// # Arguments1021 /// 1022 /// * collection_id: ID of the Collection to remove admin for.1023 /// 1024 /// * account_id: Address of admin to remove.1025 #[weight = <T as Config>::WeightInfo::remove_collection_admin()]1026 #[transactional]1027 pub fn remove_collection_admin(origin, collection_id: CollectionId, account_id: T::CrossAccountId) -> DispatchResult {1028 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1029 let collection = Self::get_collection(collection_id)?;1030 Self::check_owner_or_admin_permissions(&collection, &sender)?;1031 let mut admin_arr = <AdminList<T>>::get(collection_id);10321033 match admin_arr.binary_search(&account_id) {1034 Ok(idx) => {1035 admin_arr.remove(idx);1036 <AdminList<T>>::insert(collection_id, admin_arr);1037 },1038 Err(_) => {}1039 }1040 Ok(())1041 }10421043 /// # Permissions1044 /// 1045 /// * Collection Owner1046 /// 1047 /// # Arguments1048 /// 1049 /// * collection_id.1050 /// 1051 /// * new_sponsor.1052 #[weight = <T as Config>::WeightInfo::set_collection_sponsor()]1053 #[transactional]1054 pub fn set_collection_sponsor(origin, collection_id: CollectionId, new_sponsor: T::AccountId) -> DispatchResult {1055 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1056 let mut target_collection = Self::get_collection(collection_id)?;1057 Self::check_owner_permissions(&target_collection, &sender)?;10581059 target_collection.sponsorship = SponsorshipState::Unconfirmed(new_sponsor);1060 Self::save_collection(target_collection);10611062 Ok(())1063 }10641065 /// # Permissions1066 /// 1067 /// * Sponsor.1068 /// 1069 /// # Arguments1070 /// 1071 /// * collection_id.1072 #[weight = <T as Config>::WeightInfo::confirm_sponsorship()]1073 #[transactional]1074 pub fn confirm_sponsorship(origin, collection_id: CollectionId) -> DispatchResult {1075 let sender = ensure_signed(origin)?;10761077 let mut target_collection = Self::get_collection(collection_id)?;1078 ensure!(1079 target_collection.sponsorship.pending_sponsor() == Some(&sender),1080 Error::<T>::ConfirmUnsetSponsorFail1081 );10821083 target_collection.sponsorship = SponsorshipState::Confirmed(sender);1084 Self::save_collection(target_collection);10851086 Ok(())1087 }10881089 /// Switch back to pay-per-own-transaction model.1090 ///1091 /// # Permissions1092 ///1093 /// * Collection owner.1094 /// 1095 /// # Arguments1096 /// 1097 /// * collection_id.1098 #[weight = <T as Config>::WeightInfo::remove_collection_sponsor()]1099 #[transactional]1100 pub fn remove_collection_sponsor(origin, collection_id: CollectionId) -> DispatchResult {1101 let sender = ensure_signed(origin)?;11021103 let mut target_collection = Self::get_collection(collection_id)?;1104 Self::check_owner_permissions(&target_collection, &T::CrossAccountId::from_sub(sender))?;11051106 target_collection.sponsorship = SponsorshipState::Disabled;1107 Self::save_collection(target_collection);11081109 Ok(())1110 }11111112 /// This method creates a concrete instance of NFT Collection created with CreateCollection method.1113 /// 1114 /// # Permissions1115 /// 1116 /// * Collection Owner.1117 /// * Collection Admin.1118 /// * Anyone if1119 /// * White List is enabled, and1120 /// * Address is added to white list, and1121 /// * MintPermission is enabled (see SetMintPermission method)1122 /// 1123 /// # Arguments1124 /// 1125 /// * collection_id: ID of the collection.1126 /// 1127 /// * owner: Address, initial owner of the NFT.1128 ///1129 /// * data: Token data to store on chain.1130 // #[weight =1131 // (130_000_000 as Weight)1132 // .saturating_add((2135 as Weight).saturating_mul((properties.len() as u64) as Weight))1133 // .saturating_add(RocksDbWeight::get().reads(10 as Weight))1134 // .saturating_add(RocksDbWeight::get().writes(8 as Weight))]11351136 #[weight = <T as Config>::WeightInfo::create_item(data.len())]1137 #[transactional]1138 pub fn create_item(origin, collection_id: CollectionId, owner: T::CrossAccountId, data: CreateItemData) -> DispatchResult {11391140 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);11411142 let target_collection = Self::get_collection(collection_id)?;11431144 Self::can_create_items_in_collection(&target_collection, &sender, &owner, 1)?;1145 Self::validate_create_item_args(&target_collection, &data)?;1146 Self::create_item_no_validation(&target_collection, owner, data)?;11471148 Self::submit_logs(target_collection)?;1149 Ok(())1150 }11511152 /// This method creates multiple items in a collection created with CreateCollection method.1153 /// 1154 /// # Permissions1155 /// 1156 /// * Collection Owner.1157 /// * Collection Admin.1158 /// * Anyone if1159 /// * White List is enabled, and1160 /// * Address is added to white list, and1161 /// * MintPermission is enabled (see SetMintPermission method)1162 /// 1163 /// # Arguments1164 /// 1165 /// * collection_id: ID of the collection.1166 /// 1167 /// * itemsData: Array items properties. Each property is an array of bytes itself, see [create_item].1168 /// 1169 /// * owner: Address, initial owner of the NFT.1170 #[weight = <T as Config>::WeightInfo::create_item(items_data.into_iter()1171 .map(|data| { data.len() })1172 .sum())]1173 #[transactional]1174 pub fn create_multiple_items(origin, collection_id: CollectionId, owner: T::CrossAccountId, items_data: Vec<CreateItemData>) -> DispatchResult {11751176 ensure!(items_data.len() > 0, Error::<T>::EmptyArgument);1177 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1178 let collection = Self::get_collection(collection_id)?;11791180 Self::create_multiple_items_internal(sender, &collection, owner, items_data)?;11811182 Self::submit_logs(collection)?;1183 Ok(())1184 }11851186 /// Destroys a concrete instance of NFT.1187 /// 1188 /// # Permissions1189 /// 1190 /// * Collection Owner.1191 /// * Collection Admin.1192 /// * Current NFT Owner.1193 /// 1194 /// # Arguments1195 /// 1196 /// * collection_id: ID of the collection.1197 /// 1198 /// * item_id: ID of NFT to burn.1199 #[weight = <T as Config>::WeightInfo::burn_item()]1200 #[transactional]1201 pub fn burn_item(origin, collection_id: CollectionId, item_id: TokenId, value: u128) -> DispatchResult {12021203 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1204 let target_collection = Self::get_collection(collection_id)?;12051206 Self::burn_item_internal(&sender, &target_collection, item_id, value)?;12071208 Self::submit_logs(target_collection)?;1209 Ok(())1210 }12111212 /// Change ownership of the token.1213 /// 1214 /// # Permissions1215 /// 1216 /// * Collection Owner1217 /// * Collection Admin1218 /// * Current NFT owner1219 ///1220 /// # Arguments1221 /// 1222 /// * recipient: Address of token recipient.1223 /// 1224 /// * collection_id.1225 /// 1226 /// * item_id: ID of the item1227 /// * Non-Fungible Mode: Required.1228 /// * Fungible Mode: Ignored.1229 /// * Re-Fungible Mode: Required.1230 /// 1231 /// * value: Amount to transfer.1232 /// * Non-Fungible Mode: Ignored1233 /// * Fungible Mode: Must specify transferred amount1234 /// * Re-Fungible Mode: Must specify transferred portion (between 0 and 1)1235 #[weight = <T as Config>::WeightInfo::transfer()]1236 #[transactional]1237 pub fn transfer(origin, recipient: T::CrossAccountId, collection_id: CollectionId, item_id: TokenId, value: u128) -> DispatchResult {1238 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1239 let collection = Self::get_collection(collection_id)?;12401241 Self::transfer_internal(sender, recipient, &collection, item_id, value)?;12421243 Self::submit_logs(collection)?;1244 Ok(())1245 }12461247 /// Set, change, or remove approved address to transfer the ownership of the NFT.1248 /// 1249 /// # Permissions1250 /// 1251 /// * Collection Owner1252 /// * Collection Admin1253 /// * Current NFT owner1254 /// 1255 /// # Arguments1256 /// 1257 /// * approved: Address that is approved to transfer this NFT or zero (if needed to remove approval).1258 /// 1259 /// * collection_id.1260 /// 1261 /// * item_id: ID of the item.1262 #[weight = <T as Config>::WeightInfo::approve()]1263 #[transactional]1264 pub fn approve(origin, spender: T::CrossAccountId, collection_id: CollectionId, item_id: TokenId, amount: u128) -> DispatchResult {12651266 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1267 let collection = Self::get_collection(collection_id)?;12681269 Self::approve_internal(sender, spender, &collection, item_id, amount)?;12701271 Self::submit_logs(collection)?;1272 Ok(())1273 }1274 1275 /// 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.1276 /// 1277 /// # Permissions1278 /// * Collection Owner1279 /// * Collection Admin1280 /// * Current NFT owner1281 /// * Address approved by current NFT owner1282 /// 1283 /// # Arguments1284 /// 1285 /// * from: Address that owns token.1286 /// 1287 /// * recipient: Address of token recipient.1288 /// 1289 /// * collection_id.1290 /// 1291 /// * item_id: ID of the item.1292 /// 1293 /// * value: Amount to transfer.1294 #[weight = <T as Config>::WeightInfo::transfer_from()]1295 #[transactional]1296 pub fn transfer_from(origin, from: T::CrossAccountId, recipient: T::CrossAccountId, collection_id: CollectionId, item_id: TokenId, value: u128 ) -> DispatchResult {12971298 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1299 let collection = Self::get_collection(collection_id)?;13001301 Self::transfer_from_internal(sender, from, recipient, &collection, item_id, value)?;13021303 Self::submit_logs(collection)?;1304 Ok(())1305 }13061307 // #[weight = 0]1308 // pub fn safe_transfer_from(origin, collection_id: CollectionId, item_id: TokenId, new_owner: T::AccountId) -> DispatchResult {13091310 // // let no_perm_mes = "You do not have permissions to modify this collection";1311 // // ensure!(<ApprovedList<T>>::contains_key((collection_id, item_id)), no_perm_mes);1312 // // let list_itm = <ApprovedList<T>>::get((collection_id, item_id));1313 // // ensure!(list_itm.contains(&new_owner.clone()), no_perm_mes);13141315 // // // on_nft_received call13161317 // // Self::transfer(origin, collection_id, item_id, new_owner)?;13181319 // Ok(())1320 // }13211322 /// Set off-chain data schema.1323 /// 1324 /// # Permissions1325 /// 1326 /// * Collection Owner1327 /// * Collection Admin1328 /// 1329 /// # Arguments1330 /// 1331 /// * collection_id.1332 /// 1333 /// * schema: String representing the offchain data schema.1334 #[weight = <T as Config>::WeightInfo::set_variable_meta_data()]1335 #[transactional]1336 pub fn set_variable_meta_data (1337 origin,1338 collection_id: CollectionId,1339 item_id: TokenId,1340 data: Vec<u8>1341 ) -> DispatchResult {1342 let sender = ensure_signed(origin)?;1343 1344 let target_collection = Self::get_collection(collection_id)?;1345 Self::token_exists(&target_collection, item_id)?;13461347 ensure!(ChainLimit::get().custom_data_limit >= data.len() as u32, Error::<T>::TokenVariableDataLimitExceeded);13481349 // Modify permissions check1350 ensure!(Self::is_item_owner(sender.clone(), &target_collection, item_id) ||1351 Self::is_owner_or_admin_permissions(&target_collection, sender.clone()),1352 Error::<T>::NoPermission);13531354 match target_collection.mode1355 {1356 CollectionMode::NFT => Self::set_nft_variable_data(&target_collection, item_id, data)?,1357 CollectionMode::ReFungible => Self::set_re_fungible_variable_data(&target_collection, item_id, data)?,1358 CollectionMode::Fungible(_) => fail!(Error::<T>::CantStoreMetadataInFungibleTokens),1359 _ => fail!(Error::<T>::UnexpectedCollectionType)1360 };13611362 Ok(())1363 }1364 1365 /// Set schema standard1366 /// ImageURL1367 /// Unique1368 /// 1369 /// # Permissions1370 /// 1371 /// * Collection Owner1372 /// * Collection Admin1373 /// 1374 /// # Arguments1375 /// 1376 /// * collection_id.1377 /// 1378 /// * schema: SchemaVersion: enum1379 #[weight = <T as Config>::WeightInfo::set_schema_version()]1380 #[transactional]1381 pub fn set_schema_version(1382 origin,1383 collection_id: CollectionId,1384 version: SchemaVersion1385 ) -> DispatchResult {1386 let sender = ensure_signed(origin)?;1387 let mut target_collection = Self::get_collection(collection_id)?;1388 Self::check_owner_or_admin_permissions(&target_collection, &sender)?;1389 target_collection.schema_version = version;1390 Self::save_collection(target_collection);13911392 Ok(())1393 }13941395 /// Set off-chain data schema.1396 /// 1397 /// # Permissions1398 /// 1399 /// * Collection Owner1400 /// * Collection Admin1401 /// 1402 /// # Arguments1403 /// 1404 /// * collection_id.1405 /// 1406 /// * schema: String representing the offchain data schema.1407 #[weight = <T as Config>::WeightInfo::set_offchain_schema()]1408 #[transactional]1409 pub fn set_offchain_schema(1410 origin,1411 collection_id: CollectionId,1412 schema: Vec<u8>1413 ) -> DispatchResult {1414 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1415 let mut target_collection = Self::get_collection(collection_id)?;1416 Self::check_owner_or_admin_permissions(&target_collection, &sender)?;14171418 // check schema limit1419 ensure!(schema.len() as u32 <= ChainLimit::get().offchain_schema_limit, "");14201421 target_collection.offchain_schema = schema;1422 Self::save_collection(target_collection);14231424 Ok(())1425 }14261427 /// Set const on-chain data schema.1428 /// 1429 /// # Permissions1430 /// 1431 /// * Collection Owner1432 /// * Collection Admin1433 /// 1434 /// # Arguments1435 /// 1436 /// * collection_id.1437 /// 1438 /// * schema: String representing the const on-chain data schema.1439 #[weight = <T as Config>::WeightInfo::set_const_on_chain_schema()]1440 #[transactional]1441 pub fn set_const_on_chain_schema (1442 origin,1443 collection_id: CollectionId,1444 schema: Vec<u8>1445 ) -> DispatchResult {1446 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1447 let mut target_collection = Self::get_collection(collection_id)?;1448 Self::check_owner_or_admin_permissions(&target_collection, &sender)?;14491450 // check schema limit1451 ensure!(schema.len() as u32 <= ChainLimit::get().const_on_chain_schema_limit, "");14521453 target_collection.const_on_chain_schema = schema;1454 Self::save_collection(target_collection);14551456 Ok(())1457 }14581459 /// Set variable on-chain data schema.1460 /// 1461 /// # Permissions1462 /// 1463 /// * Collection Owner1464 /// * Collection Admin1465 /// 1466 /// # Arguments1467 /// 1468 /// * collection_id.1469 /// 1470 /// * schema: String representing the variable on-chain data schema.1471 #[weight = <T as Config>::WeightInfo::set_const_on_chain_schema()]1472 #[transactional]1473 pub fn set_variable_on_chain_schema (1474 origin,1475 collection_id: CollectionId,1476 schema: Vec<u8>1477 ) -> DispatchResult {1478 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1479 let mut target_collection = Self::get_collection(collection_id)?;1480 Self::check_owner_or_admin_permissions(&target_collection, &sender)?;14811482 // check schema limit1483 ensure!(schema.len() as u32 <= ChainLimit::get().variable_on_chain_schema_limit, "");14841485 target_collection.variable_on_chain_schema = schema;1486 Self::save_collection(target_collection);14871488 Ok(())1489 }14901491 // Sudo permissions function1492 #[weight = <T as Config>::WeightInfo::set_chain_limits()]1493 #[transactional]1494 pub fn set_chain_limits(1495 origin,1496 limits: ChainLimits1497 ) -> DispatchResult {14981499 #[cfg(not(feature = "runtime-benchmarks"))]1500 ensure_root(origin)?;15011502 <ChainLimit>::put(limits);1503 Ok(())1504 }15051506 /// Enable smart contract self-sponsoring.1507 /// 1508 /// # Permissions1509 /// 1510 /// * Contract Owner1511 /// 1512 /// # Arguments1513 /// 1514 /// * contract address1515 /// * enable flag1516 /// 1517 #[weight = <T as Config>::WeightInfo::enable_contract_sponsoring()]1518 #[transactional]1519 pub fn enable_contract_sponsoring(1520 origin,1521 contract_address: T::AccountId,1522 enable: bool1523 ) -> DispatchResult {15241525 let sender = ensure_signed(origin)?;15261527 #[cfg(feature = "runtime-benchmarks")]1528 <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());15291530 Self::ensure_contract_owned(sender, &contract_address)?;15311532 <ContractSelfSponsoring<T>>::insert(contract_address, enable);1533 Ok(())1534 }15351536 /// Set the rate limit for contract sponsoring to specified number of blocks.1537 /// 1538 /// If not set (has the default value of 0 blocks), the sponsoring will be disabled. 1539 /// If set to the number B (for blocks), the transactions will be sponsored with a rate 1540 /// limit of B, i.e. fees for every transaction sent to this smart contract will be paid 1541 /// from contract endowment if there are at least B blocks between such transactions. 1542 /// Nonetheless, if transactions are sent more frequently, the fees are paid by the sender.1543 /// 1544 /// # Permissions1545 /// 1546 /// * Contract Owner1547 /// 1548 /// # Arguments1549 /// 1550 /// -`contract_address`: Address of the contract to sponsor1551 /// -`rate_limit`: Number of blocks to wait until the next sponsored transaction is allowed1552 /// 1553 #[weight = <T as Config>::WeightInfo::set_contract_sponsoring_rate_limit()]1554 #[transactional]1555 pub fn set_contract_sponsoring_rate_limit(1556 origin,1557 contract_address: T::AccountId,1558 rate_limit: T::BlockNumber1559 ) -> DispatchResult {1560 let sender = ensure_signed(origin)?;15611562 #[cfg(feature = "runtime-benchmarks")]1563 <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());15641565 Self::ensure_contract_owned(sender, &contract_address)?;1566 <ContractSponsoringRateLimit<T>>::insert(contract_address, rate_limit);1567 Ok(())1568 }15691570 /// Enable the white list for a contract. Only addresses added to the white list with addToContractWhiteList will be able to call this smart contract.1571 /// 1572 /// # Permissions1573 /// 1574 /// * Address that deployed smart contract.1575 /// 1576 /// # Arguments1577 /// 1578 /// -`contract_address`: Address of the contract.1579 /// 1580 /// - `enable`: . 1581 #[weight = <T as Config>::WeightInfo::toggle_contract_white_list()]1582 #[transactional]1583 pub fn toggle_contract_white_list(1584 origin,1585 contract_address: T::AccountId,1586 enable: bool1587 ) -> DispatchResult {1588 let sender = ensure_signed(origin)?;15891590 #[cfg(feature = "runtime-benchmarks")]1591 <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());15921593 Self::ensure_contract_owned(sender, &contract_address)?;1594 if enable {1595 <ContractWhiteListEnabled<T>>::insert(contract_address, true);1596 } else {1597 <ContractWhiteListEnabled<T>>::remove(contract_address);1598 }1599 Ok(())1600 }1601 1602 /// Add an address to smart contract white list.1603 /// 1604 /// # Permissions1605 /// 1606 /// * Address that deployed smart contract.1607 /// 1608 /// # Arguments1609 /// 1610 /// -`contract_address`: Address of the contract.1611 ///1612 /// -`account_address`: Address to add.1613 #[weight = <T as Config>::WeightInfo::add_to_contract_white_list()]1614 #[transactional]1615 pub fn add_to_contract_white_list(1616 origin,1617 contract_address: T::AccountId,1618 account_address: T::AccountId1619 ) -> DispatchResult {1620 let sender = ensure_signed(origin)?;16211622 #[cfg(feature = "runtime-benchmarks")]1623 <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());1624 1625 Self::ensure_contract_owned(sender, &contract_address)?; 1626 <ContractWhiteList<T>>::insert(contract_address, account_address, true);1627 Ok(())1628 }16291630 /// Remove an address from smart contract white list.1631 /// 1632 /// # Permissions1633 /// 1634 /// * Address that deployed smart contract.1635 /// 1636 /// # Arguments1637 /// 1638 /// -`contract_address`: Address of the contract.1639 ///1640 /// -`account_address`: Address to remove.1641 #[weight = <T as Config>::WeightInfo::remove_from_contract_white_list()]1642 #[transactional]1643 pub fn remove_from_contract_white_list(1644 origin,1645 contract_address: T::AccountId,1646 account_address: T::AccountId1647 ) -> DispatchResult {1648 let sender = ensure_signed(origin)?;16491650 #[cfg(feature = "runtime-benchmarks")]1651 <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());16521653 Self::ensure_contract_owned(sender, &contract_address)?;1654 <ContractWhiteList<T>>::remove(contract_address, account_address);1655 Ok(())1656 }16571658 #[weight = <T as Config>::WeightInfo::set_collection_limits()]1659 #[transactional]1660 pub fn set_collection_limits(1661 origin,1662 collection_id: u32,1663 new_limits: CollectionLimits<T::BlockNumber>,1664 ) -> DispatchResult {1665 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1666 let mut target_collection = Self::get_collection(collection_id)?;1667 Self::check_owner_permissions(&target_collection, &sender)?;1668 let old_limits = &target_collection.limits;1669 let chain_limits = ChainLimit::get();16701671 // collection bounds1672 ensure!(new_limits.sponsor_transfer_timeout <= MAX_SPONSOR_TIMEOUT &&1673 new_limits.account_token_ownership_limit <= MAX_TOKEN_OWNERSHIP && 1674 new_limits.sponsored_data_size <= chain_limits.custom_data_limit,1675 Error::<T>::CollectionLimitBoundsExceeded);16761677 // token_limit check prev1678 ensure!(old_limits.token_limit >= new_limits.token_limit, Error::<T>::CollectionTokenLimitExceeded);1679 ensure!(new_limits.token_limit > 0, Error::<T>::CollectionTokenLimitExceeded);16801681 ensure!(1682 (old_limits.owner_can_transfer || !new_limits.owner_can_transfer) &&1683 (old_limits.owner_can_destroy || !new_limits.owner_can_destroy),1684 Error::<T>::OwnerPermissionsCantBeReverted,1685 );16861687 target_collection.limits = new_limits;1688 Self::save_collection(target_collection);16891690 Ok(())1691 } 1692 }1693}16941695impl<T: Config> Module<T> {16961697 pub fn transfer_internal(sender: T::CrossAccountId, recipient: T::CrossAccountId, target_collection: &CollectionHandle<T>, item_id: TokenId, value: u128) -> DispatchResult {1698 // Limits check1699 Self::is_correct_transfer(target_collection, &recipient)?;17001701 // Transfer permissions check1702 ensure!(Self::is_item_owner(&sender, target_collection, item_id) ||1703 Self::is_owner_or_admin_permissions(target_collection, &sender),1704 Error::<T>::NoPermission);17051706 if target_collection.access == AccessMode::WhiteList {1707 Self::check_white_list(target_collection, &sender)?;1708 Self::check_white_list(target_collection, &recipient)?;1709 }17101711 match target_collection.mode1712 {1713 CollectionMode::NFT => Self::transfer_nft(target_collection, item_id, sender.clone(), recipient.clone())?,1714 CollectionMode::Fungible(_) => Self::transfer_fungible(target_collection, value, &sender, &recipient)?,1715 CollectionMode::ReFungible => Self::transfer_refungible(target_collection, item_id, value, sender.clone(), recipient.clone())?,1716 _ => ()1717 };17181719 Self::deposit_event(RawEvent::Transfer(target_collection.id, item_id, sender, recipient, value));17201721 Ok(())1722 }17231724 pub fn approve_internal(1725 sender: T::CrossAccountId,1726 spender: T::CrossAccountId,1727 collection: &CollectionHandle<T>,1728 item_id: TokenId,1729 amount: u1281730 ) -> DispatchResult {1731 Self::token_exists(&collection, item_id)?;17321733 // Transfer permissions check1734 let bypasses_limits = collection.limits.owner_can_transfer &&1735 Self::is_owner_or_admin_permissions(1736 &collection,1737 &sender,1738 );17391740 let allowance_limit = if bypasses_limits {1741 None1742 } else if let Some(amount) = Self::owned_amount(1743 &sender,1744 &collection,1745 item_id,1746 ) {1747 Some(amount)1748 } else {1749 fail!(Error::<T>::NoPermission);1750 };17511752 if collection.access == AccessMode::WhiteList {1753 Self::check_white_list(&collection, &sender)?;1754 Self::check_white_list(&collection, &spender)?;1755 }17561757 let allowance: u128 = amount1758 .checked_add(<Allowances<T>>::get(collection.id, (item_id, sender.as_sub(), spender.as_sub())))1759 .ok_or(Error::<T>::NumOverflow)?;1760 if let Some(limit) = allowance_limit {1761 ensure!(limit >= allowance, Error::<T>::TokenValueTooLow);1762 }1763 <Allowances<T>>::insert(collection.id, (item_id, sender.as_sub(), spender.as_sub()), allowance);17641765 if matches!(collection.mode, CollectionMode::NFT) {1766 // TODO: NFT: only one owner may exist for token in ERC7211767 collection.log(1768 Vec::from([1769 eth::APPROVAL_NFT_TOPIC,1770 eth::address_to_topic(sender.as_eth()),1771 eth::address_to_topic(spender.as_eth()),1772 ]),1773 abi_encode!(uint256(item_id.into())),1774 );1775 }17761777 if matches!(collection.mode, CollectionMode::Fungible(_)) {1778 // TODO: NFT: only one owner may exist for token in ERC201779 collection.log(1780 Vec::from([1781 eth::APPROVAL_FUNGIBLE_TOPIC,1782 eth::address_to_topic(sender.as_eth()),1783 eth::address_to_topic(spender.as_eth()),1784 ]),1785 abi_encode!(uint256(allowance.into())),1786 );1787 }17881789 Self::deposit_event(RawEvent::Approved(collection.id, item_id, sender, spender, allowance));1790 Ok(())1791 }17921793 pub fn transfer_from_internal(1794 sender: T::CrossAccountId,1795 from: T::CrossAccountId,1796 recipient: T::CrossAccountId,1797 collection: &CollectionHandle<T>,1798 item_id: TokenId,1799 amount: u128,1800 ) -> DispatchResult {1801 // Check approval1802 let approval: u128 = <Allowances<T>>::get(collection.id, (item_id, from.as_sub(), sender.as_sub()));18031804 // Limits check1805 Self::is_correct_transfer(&collection, &recipient)?;18061807 // Transfer permissions check1808 ensure!(1809 approval >= amount || 1810 (1811 collection.limits.owner_can_transfer &&1812 Self::is_owner_or_admin_permissions(&collection, &sender)1813 ),1814 Error::<T>::NoPermission1815 );18161817 if collection.access == AccessMode::WhiteList {1818 Self::check_white_list(&collection, &sender)?;1819 Self::check_white_list(&collection, &recipient)?;1820 }18211822 // Reduce approval by transferred amount or remove if remaining approval drops to 01823 let allowance = approval.saturating_sub(amount);1824 if allowance > 0 {1825 <Allowances<T>>::insert(collection.id, (item_id, from.as_sub(), sender.as_sub()), allowance);1826 } else {1827 <Allowances<T>>::remove(collection.id, (item_id, from.as_sub(), sender.as_sub()));1828 }18291830 match collection.mode {1831 CollectionMode::NFT => {1832 Self::transfer_nft(&collection, item_id, from.clone(), recipient.clone())?1833 }1834 CollectionMode::Fungible(_) => {1835 Self::transfer_fungible(&collection, amount, &from, &recipient)?1836 }1837 CollectionMode::ReFungible => {1838 Self::transfer_refungible(&collection, item_id, amount, from.clone(), recipient.clone())?1839 }1840 _ => ()1841 };18421843 if matches!(collection.mode, CollectionMode::Fungible(_)) {1844 collection.log(1845 Vec::from([1846 eth::APPROVAL_FUNGIBLE_TOPIC,1847 eth::address_to_topic(from.as_eth()),1848 eth::address_to_topic(sender.as_eth()),1849 ]),1850 abi_encode!(uint256(allowance.into())),1851 );1852 }18531854 Ok(())1855 }18561857 pub fn create_multiple_items_internal(1858 sender: T::CrossAccountId,1859 collection: &CollectionHandle<T>,1860 owner: T::CrossAccountId,1861 items_data: Vec<CreateItemData>,1862 ) -> DispatchResult {1863 Self::can_create_items_in_collection(&collection, &sender, &owner, items_data.len() as u32)?;18641865 for data in &items_data {1866 Self::validate_create_item_args(&collection, data)?;1867 }1868 for data in &items_data {1869 Self::create_item_no_validation(&collection, owner.clone(), data.clone())?;1870 }18711872 Ok(())1873 }18741875 pub fn burn_item_internal(1876 sender: &T::CrossAccountId,1877 collection: &CollectionHandle<T>,1878 item_id: TokenId,1879 value: u128,1880 ) -> DispatchResult {1881 ensure!(1882 Self::is_item_owner(&sender, &collection, item_id) ||1883 (1884 collection.limits.owner_can_transfer &&1885 Self::is_owner_or_admin_permissions(&collection, &sender)1886 ),1887 Error::<T>::NoPermission1888 );18891890 if collection.access == AccessMode::WhiteList {1891 Self::check_white_list(&collection, &sender)?;1892 }18931894 match collection.mode1895 {1896 CollectionMode::NFT => Self::burn_nft_item(&collection, item_id)?,1897 CollectionMode::Fungible(_) => Self::burn_fungible_item(&sender, &collection, value)?,1898 CollectionMode::ReFungible => Self::burn_refungible_item(&collection, item_id, &sender)?,1899 _ => ()1900 };19011902 Ok(())1903 }19041905 fn is_correct_transfer(collection: &CollectionHandle<T>, recipient: &T::CrossAccountId) -> DispatchResult {1906 let collection_id = collection.id;19071908 // check token limit and account token limit1909 let account_items: u32 = <AddressTokens<T>>::get(collection_id, recipient.as_sub()).len() as u32;1910 ensure!(collection.limits.account_token_ownership_limit > account_items, Error::<T>::AccountTokenLimitExceeded);1911 1912 Ok(())1913 }19141915 fn can_create_items_in_collection(collection: &CollectionHandle<T>, sender: &T::CrossAccountId, owner: &T::CrossAccountId, amount: u32) -> DispatchResult {1916 let collection_id = collection.id;19171918 // check token limit and account token limit1919 let total_items: u32 = ItemListIndex::get(collection_id)1920 .checked_add(amount)1921 .ok_or(Error::<T>::CollectionTokenLimitExceeded)?;1922 let account_items: u32 = (<AddressTokens<T>>::get(collection_id, owner.as_sub()).len() as u32)1923 .checked_add(amount)1924 .ok_or(Error::<T>::AccountTokenLimitExceeded)?;1925 ensure!(collection.limits.token_limit >= total_items, Error::<T>::CollectionTokenLimitExceeded);1926 ensure!(collection.limits.account_token_ownership_limit >= account_items, Error::<T>::AccountTokenLimitExceeded);19271928 if !Self::is_owner_or_admin_permissions(collection, &sender) {1929 ensure!(collection.mint_mode == true, Error::<T>::PublicMintingNotAllowed);1930 Self::check_white_list(collection, owner)?;1931 Self::check_white_list(collection, sender)?;1932 }19331934 Ok(())1935 }19361937 fn validate_create_item_args(target_collection: &CollectionHandle<T>, data: &CreateItemData) -> DispatchResult {1938 match target_collection.mode1939 {1940 CollectionMode::NFT => {1941 if let CreateItemData::NFT(data) = data {1942 // check sizes1943 ensure!(ChainLimit::get().custom_data_limit >= data.const_data.len() as u32, Error::<T>::TokenConstDataLimitExceeded);1944 ensure!(ChainLimit::get().custom_data_limit >= data.variable_data.len() as u32, Error::<T>::TokenVariableDataLimitExceeded);1945 } else {1946 fail!(Error::<T>::NotNftDataUsedToMintNftCollectionToken);1947 }1948 },1949 CollectionMode::Fungible(_) => {1950 if let CreateItemData::Fungible(_) = data {1951 } else {1952 fail!(Error::<T>::NotFungibleDataUsedToMintFungibleCollectionToken);1953 }1954 },1955 CollectionMode::ReFungible => {1956 if let CreateItemData::ReFungible(data) = data {19571958 // check sizes1959 ensure!(ChainLimit::get().custom_data_limit >= data.const_data.len() as u32, Error::<T>::TokenConstDataLimitExceeded);1960 ensure!(ChainLimit::get().custom_data_limit >= data.variable_data.len() as u32, Error::<T>::TokenVariableDataLimitExceeded);19611962 // Check refungibility limits1963 ensure!(data.pieces <= MAX_REFUNGIBLE_PIECES, Error::<T>::WrongRefungiblePieces);1964 ensure!(data.pieces > 0, Error::<T>::WrongRefungiblePieces);1965 } else {1966 fail!(Error::<T>::NotReFungibleDataUsedToMintReFungibleCollectionToken);1967 }1968 },1969 _ => { fail!(Error::<T>::UnexpectedCollectionType); }1970 };19711972 Ok(())1973 }19741975 fn create_item_no_validation(collection: &CollectionHandle<T>, owner: T::CrossAccountId, data: CreateItemData) -> DispatchResult {1976 match data1977 {1978 CreateItemData::NFT(data) => {1979 let item = NftItemType {1980 owner: owner.clone(),1981 const_data: data.const_data,1982 variable_data: data.variable_data1983 };19841985 Self::add_nft_item(collection, item)?;1986 },1987 CreateItemData::Fungible(data) => {1988 Self::add_fungible_item(collection, &owner, data.value)?;1989 },1990 CreateItemData::ReFungible(data) => {1991 let mut owner_list = Vec::new();1992 owner_list.push(Ownership {owner: owner.clone(), fraction: data.pieces});19931994 let item = ReFungibleItemType {1995 owner: owner_list,1996 const_data: data.const_data,1997 variable_data: data.variable_data1998 };19992000 Self::add_refungible_item(collection, item)?;2001 }2002 };20032004 Ok(())2005 }20062007 fn add_fungible_item(collection: &CollectionHandle<T>, owner: &T::CrossAccountId, value: u128) -> DispatchResult {2008 let collection_id = collection.id;20092010 // Does new owner already have an account?2011 let balance: u128 = <FungibleItemList<T>>::get(collection_id, owner.as_sub()).value;20122013 // Mint 2014 let item = FungibleItemType {2015 value: balance.checked_add(value).ok_or(Error::<T>::NumOverflow)?,2016 };2017 <FungibleItemList<T>>::insert(collection_id, owner.as_sub(), item);20182019 // Update balance2020 let new_balance = <Balance<T>>::get(collection_id, owner.as_sub())2021 .checked_add(value)2022 .ok_or(Error::<T>::NumOverflow)?;2023 <Balance<T>>::insert(collection_id, owner.as_sub(), new_balance);20242025 Self::deposit_event(RawEvent::ItemCreated(collection_id, 0, owner.clone()));2026 Ok(())2027 }20282029 fn add_refungible_item(collection: &CollectionHandle<T>, item: ReFungibleItemType<T::CrossAccountId>) -> DispatchResult {2030 let collection_id = collection.id;20312032 let current_index = <ItemListIndex>::get(collection_id)2033 .checked_add(1)2034 .ok_or(Error::<T>::NumOverflow)?;2035 let itemcopy = item.clone();20362037 ensure!(2038 item.owner.len() == 1,2039 Error::<T>::BadCreateRefungibleCall,2040 );2041 let item_owner = item.owner.first().expect("only one owner is defined");20422043 let value = item_owner.fraction;2044 let owner = item_owner.owner.clone();20452046 Self::add_token_index(collection_id, current_index, &owner)?;20472048 <ItemListIndex>::insert(collection_id, current_index);2049 <ReFungibleItemList<T>>::insert(collection_id, current_index, itemcopy);20502051 // Update balance2052 let new_balance = <Balance<T>>::get(collection_id, owner.as_sub())2053 .checked_add(value)2054 .ok_or(Error::<T>::NumOverflow)?;2055 <Balance<T>>::insert(collection_id, owner.as_sub(), new_balance);20562057 Self::deposit_event(RawEvent::ItemCreated(collection_id, current_index, owner));2058 Ok(())2059 }20602061 fn add_nft_item(collection: &CollectionHandle<T>, item: NftItemType<T::CrossAccountId>) -> DispatchResult {2062 let collection_id = collection.id;20632064 let current_index = <ItemListIndex>::get(collection_id)2065 .checked_add(1)2066 .ok_or(Error::<T>::NumOverflow)?;20672068 let item_owner = item.owner.clone();2069 Self::add_token_index(collection_id, current_index, &item.owner)?;20702071 <ItemListIndex>::insert(collection_id, current_index);2072 <NftItemList<T>>::insert(collection_id, current_index, item);20732074 // Update balance2075 let new_balance = <Balance<T>>::get(collection_id, item_owner.as_sub())2076 .checked_add(1)2077 .ok_or(Error::<T>::NumOverflow)?;2078 <Balance<T>>::insert(collection_id, item_owner.as_sub(), new_balance);20792080 collection.log(2081 Vec::from([2082 eth::TRANSFER_NFT_TOPIC,2083 eth::address_to_topic(&H160::default()),2084 eth::address_to_topic(item_owner.as_eth()),2085 ]),2086 abi_encode!(uint256(current_index.into())),2087 );2088 Self::deposit_event(RawEvent::ItemCreated(collection_id, current_index, item_owner));2089 Ok(())2090 }20912092 fn burn_refungible_item(2093 collection: &CollectionHandle<T>,2094 item_id: TokenId,2095 owner: &T::CrossAccountId,2096 ) -> DispatchResult {2097 let collection_id = collection.id;20982099 let mut token = <ReFungibleItemList<T>>::get(collection_id, item_id)2100 .ok_or(Error::<T>::TokenNotFound)?;2101 let rft_balance = token2102 .owner2103 .iter()2104 .find(|&i| i.owner == *owner)2105 .ok_or(Error::<T>::TokenNotFound)?;2106 Self::remove_token_index(collection_id, item_id, owner)?;21072108 // update balance2109 let new_balance = <Balance<T>>::get(collection_id, rft_balance.owner.as_sub())2110 .checked_sub(rft_balance.fraction)2111 .ok_or(Error::<T>::NumOverflow)?;2112 <Balance<T>>::insert(collection_id, rft_balance.owner.as_sub(), new_balance);21132114 // Re-create owners list with sender removed2115 let index = token2116 .owner2117 .iter()2118 .position(|i| i.owner == *owner)2119 .expect("owned item is exists");2120 token.owner.remove(index);2121 let owner_count = token.owner.len();21222123 // Burn the token completely if this was the last (only) owner2124 if owner_count == 0 {2125 <ReFungibleItemList<T>>::remove(collection_id, item_id);2126 <VariableMetaDataBasket<T>>::remove(collection_id, item_id);2127 }2128 else {2129 <ReFungibleItemList<T>>::insert(collection_id, item_id, token);2130 }21312132 Ok(())2133 }21342135 fn burn_nft_item(collection: &CollectionHandle<T>, item_id: TokenId) -> DispatchResult {2136 let collection_id = collection.id;21372138 let item = <NftItemList<T>>::get(collection_id, item_id)2139 .ok_or(Error::<T>::TokenNotFound)?;2140 Self::remove_token_index(collection_id, item_id, &item.owner)?;21412142 // update balance2143 let new_balance = <Balance<T>>::get(collection_id, item.owner.as_sub())2144 .checked_sub(1)2145 .ok_or(Error::<T>::NumOverflow)?;2146 <Balance<T>>::insert(collection_id, item.owner.as_sub(), new_balance);2147 <NftItemList<T>>::remove(collection_id, item_id);2148 <VariableMetaDataBasket<T>>::remove(collection_id, item_id);21492150 Self::deposit_event(RawEvent::ItemDestroyed(collection.id, item_id));2151 Ok(())2152 }21532154 fn burn_fungible_item(owner: &T::CrossAccountId, collection: &CollectionHandle<T>, value: u128) -> DispatchResult {2155 let collection_id = collection.id;21562157 let mut balance = <FungibleItemList<T>>::get(collection_id, owner.as_sub());2158 ensure!(balance.value >= value, Error::<T>::TokenValueNotEnough);21592160 // update balance2161 let new_balance = <Balance<T>>::get(collection_id, owner.as_sub())2162 .checked_sub(value)2163 .ok_or(Error::<T>::NumOverflow)?;2164 <Balance<T>>::insert(collection_id, owner.as_sub(), new_balance);21652166 if balance.value - value > 0 {2167 balance.value -= value;2168 <FungibleItemList<T>>::insert(collection_id, owner.as_sub(), balance);2169 }2170 else {2171 <FungibleItemList<T>>::remove(collection_id, owner.as_sub());2172 }21732174 collection.log(2175 Vec::from([2176 eth::TRANSFER_FUNGIBLE_TOPIC,2177 eth::address_to_topic(owner.as_eth()),2178 eth::address_to_topic(&H160::default()),2179 ]),2180 abi_encode!(uint256(value.into())),2181 );2182 Ok(())2183 }21842185 pub fn get_collection(collection_id: CollectionId) -> Result<CollectionHandle<T>, sp_runtime::DispatchError> {2186 Ok(<CollectionHandle<T>>::get(collection_id)2187 .ok_or(Error::<T>::CollectionNotFound)?)2188 }21892190 fn save_collection(collection: CollectionHandle<T>) {2191 <CollectionById<T>>::insert(collection.id, collection.into_inner());2192 }21932194 fn submit_logs(collection: CollectionHandle<T>) -> DispatchResult {2195 T::EthereumTransactionSender::submit_logs_transaction(2196 eth::generate_transaction(collection.id, T::EthereumChainId::get()),2197 collection.logs.retrieve_logs_for_contract(eth::collection_id_to_address(collection.id)),2198 )2199 }22002201 fn check_owner_permissions(target_collection: &CollectionHandle<T>, subject: &T::CrossAccountId) -> DispatchResult {2202 ensure!(2203 *subject == target_collection.owner,2204 Error::<T>::NoPermission2205 );22062207 Ok(())2208 }22092210 fn is_owner_or_admin_permissions(collection: &CollectionHandle<T>, subject: &T::CrossAccountId) -> bool {2211 *subject == collection.owner || <AdminList<T>>::get(collection.id).contains(&subject)2212 }22132214 fn check_owner_or_admin_permissions(2215 collection: &CollectionHandle<T>,2216 subject: &T::CrossAccountId,2217 ) -> DispatchResult {2218 ensure!(Self::is_owner_or_admin_permissions(collection, subject), Error::<T>::NoPermission);22192220 Ok(())2221 }22222223 fn owned_amount(2224 subject: &T::CrossAccountId,2225 target_collection: &CollectionHandle<T>,2226 item_id: TokenId,2227 ) -> Option<u128> {2228 let collection_id = target_collection.id;22292230 match target_collection.mode {2231 CollectionMode::NFT => (<NftItemList<T>>::get(collection_id, item_id)?.owner == *subject)2232 .then(|| 1),2233 CollectionMode::Fungible(_) => Some(<FungibleItemList<T>>::get(collection_id, &subject.as_sub())2234 .value),2235 CollectionMode::ReFungible => <ReFungibleItemList<T>>::get(collection_id, item_id)?2236 .owner2237 .iter()2238 .find(|i| i.owner == *subject)2239 .map(|i| i.fraction),2240 CollectionMode::Invalid => None,2241 }2242 }22432244 fn is_item_owner(subject: &T::CrossAccountId, target_collection: &CollectionHandle<T>, item_id: TokenId) -> bool {2245 match target_collection.mode {2246 CollectionMode::Fungible(_) => true,2247 _ => Self::owned_amount(&subject, target_collection, item_id).is_some(),2248 }2249 }22502251 fn check_white_list(collection: &CollectionHandle<T>, address: &T::CrossAccountId) -> DispatchResult {2252 let collection_id = collection.id;22532254 let mes = Error::<T>::AddresNotInWhiteList;2255 ensure!(<WhiteList<T>>::contains_key(collection_id, address.as_sub()), mes);22562257 Ok(())2258 }22592260 /// Check if token exists. In case of Fungible, check if there is an entry for 2261 /// the owner in fungible balances double map2262 fn token_exists(2263 target_collection: &CollectionHandle<T>,2264 item_id: TokenId,2265 ) -> DispatchResult {2266 let collection_id = target_collection.id;2267 let exists = match target_collection.mode2268 {2269 CollectionMode::NFT => <NftItemList<T>>::contains_key(collection_id, item_id),2270 CollectionMode::Fungible(_) => true,2271 CollectionMode::ReFungible => <ReFungibleItemList<T>>::contains_key(collection_id, item_id),2272 _ => false2273 };22742275 ensure!(exists == true, Error::<T>::TokenNotFound);2276 Ok(())2277 }22782279 fn transfer_fungible(2280 collection: &CollectionHandle<T>,2281 value: u128,2282 owner: &T::CrossAccountId,2283 recipient: &T::CrossAccountId,2284 ) -> DispatchResult {2285 let collection_id = collection.id;22862287 let mut balance = <FungibleItemList<T>>::get(collection_id, owner.as_sub());2288 ensure!(balance.value >= value, Error::<T>::TokenValueTooLow);22892290 // Send balance to recipient (updates balanceOf of recipient)2291 Self::add_fungible_item(collection, recipient, value)?;22922293 // update balanceOf of sender2294 <Balance<T>>::insert(collection_id, owner.as_sub(), balance.value - value);22952296 // Reduce or remove sender2297 if balance.value == value {2298 <FungibleItemList<T>>::remove(collection_id, owner.as_sub());2299 }2300 else {2301 balance.value -= value;2302 <FungibleItemList<T>>::insert(collection_id, owner.as_sub(), balance);2303 }23042305 collection.log(2306 Vec::from([2307 eth::TRANSFER_FUNGIBLE_TOPIC,2308 eth::address_to_topic(owner.as_eth()),2309 eth::address_to_topic(recipient.as_eth()),2310 ]),2311 abi_encode!(uint256(value.into())),2312 );2313 Self::deposit_event(RawEvent::Transfer(collection.id, 1, owner.clone(), recipient.clone(), value));23142315 Ok(())2316 }23172318 fn transfer_refungible(2319 collection: &CollectionHandle<T>,2320 item_id: TokenId,2321 value: u128,2322 owner: T::CrossAccountId,2323 new_owner: T::CrossAccountId,2324 ) -> DispatchResult {2325 let collection_id = collection.id;2326 let full_item = <ReFungibleItemList<T>>::get(collection_id, item_id)2327 .ok_or(Error::<T>::TokenNotFound)?;23282329 let item = full_item2330 .owner2331 .iter()2332 .filter(|i| i.owner == owner)2333 .next()2334 .ok_or(Error::<T>::TokenNotFound)?;2335 let amount = item.fraction;23362337 ensure!(amount >= value, Error::<T>::TokenValueTooLow);23382339 // update balance2340 let balance_old_owner = <Balance<T>>::get(collection_id, item.owner.as_sub())2341 .checked_sub(value)2342 .ok_or(Error::<T>::NumOverflow)?;2343 <Balance<T>>::insert(collection_id, item.owner.as_sub(), balance_old_owner);23442345 let balance_new_owner = <Balance<T>>::get(collection_id, new_owner.as_sub())2346 .checked_add(value)2347 .ok_or(Error::<T>::NumOverflow)?;2348 <Balance<T>>::insert(collection_id, new_owner.as_sub(), balance_new_owner);23492350 let old_owner = item.owner.clone();2351 let new_owner_has_account = full_item.owner.iter().any(|i| i.owner == new_owner);23522353 // transfer2354 if amount == value && !new_owner_has_account {2355 // change owner2356 // new owner do not have account2357 let mut new_full_item = full_item.clone();2358 new_full_item2359 .owner2360 .iter_mut()2361 .find(|i| i.owner == owner)2362 .expect("old owner does present in refungible")2363 .owner = new_owner.clone();2364 <ReFungibleItemList<T>>::insert(collection_id, item_id, new_full_item);23652366 // update index collection2367 Self::move_token_index(collection_id, item_id, &old_owner, &new_owner)?;2368 } else {2369 let mut new_full_item = full_item.clone();2370 new_full_item2371 .owner2372 .iter_mut()2373 .find(|i| i.owner == owner)2374 .expect("old owner does present in refungible")2375 .fraction -= value;23762377 // separate amount2378 if new_owner_has_account {2379 // new owner has account2380 new_full_item2381 .owner2382 .iter_mut()2383 .find(|i| i.owner == new_owner)2384 .expect("new owner has account")2385 .fraction += value;2386 } else {2387 // new owner do not have account2388 new_full_item.owner.push(Ownership {2389 owner: new_owner.clone(),2390 fraction: value,2391 });2392 Self::add_token_index(collection_id, item_id, &new_owner)?;2393 }23942395 <ReFungibleItemList<T>>::insert(collection_id, item_id, new_full_item);2396 }23972398 Self::deposit_event(RawEvent::Transfer(collection.id, item_id, owner, new_owner, amount));23992400 Ok(())2401 }24022403 fn transfer_nft(2404 collection: &CollectionHandle<T>,2405 item_id: TokenId,2406 sender: T::CrossAccountId,2407 new_owner: T::CrossAccountId,2408 ) -> DispatchResult {2409 let collection_id = collection.id;2410 let mut item = <NftItemList<T>>::get(collection_id, item_id)2411 .ok_or(Error::<T>::TokenNotFound)?;24122413 ensure!(2414 sender == item.owner,2415 Error::<T>::MustBeTokenOwner2416 );24172418 // update balance2419 let balance_old_owner = <Balance<T>>::get(collection_id, item.owner.as_sub())2420 .checked_sub(1)2421 .ok_or(Error::<T>::NumOverflow)?;2422 <Balance<T>>::insert(collection_id, item.owner.as_sub(), balance_old_owner);24232424 let balance_new_owner = <Balance<T>>::get(collection_id, new_owner.as_sub())2425 .checked_add(1)2426 .ok_or(Error::<T>::NumOverflow)?;2427 <Balance<T>>::insert(collection_id, new_owner.as_sub(), balance_new_owner);24282429 // change owner2430 let old_owner = item.owner.clone();2431 item.owner = new_owner.clone();2432 <NftItemList<T>>::insert(collection_id, item_id, item);24332434 // update index collection2435 Self::move_token_index(collection_id, item_id, &old_owner, &new_owner)?;24362437 collection.log(2438 Vec::from([2439 eth::TRANSFER_NFT_TOPIC,2440 eth::address_to_topic(sender.as_eth()),2441 eth::address_to_topic(new_owner.as_eth()),2442 ]),2443 abi_encode!(uint256(item_id.into())),2444 );2445 Self::deposit_event(RawEvent::Transfer(collection.id, item_id, sender, new_owner, 1));24462447 Ok(())2448 }2449 2450 fn set_re_fungible_variable_data(2451 collection: &CollectionHandle<T>,2452 item_id: TokenId,2453 data: Vec<u8>2454 ) -> DispatchResult {2455 let collection_id = collection.id;2456 let mut item = <ReFungibleItemList<T>>::get(collection_id, item_id)2457 .ok_or(Error::<T>::TokenNotFound)?;24582459 item.variable_data = data;24602461 <ReFungibleItemList<T>>::insert(collection_id, item_id, item);24622463 Ok(())2464 }24652466 fn set_nft_variable_data(2467 collection: &CollectionHandle<T>,2468 item_id: TokenId,2469 data: Vec<u8>2470 ) -> DispatchResult {2471 let collection_id = collection.id;2472 let mut item = <NftItemList<T>>::get(collection_id, item_id)2473 .ok_or(Error::<T>::TokenNotFound)?;2474 2475 item.variable_data = data;24762477 <NftItemList<T>>::insert(collection_id, item_id, item);2478 2479 Ok(())2480 }24812482 fn init_collection(item: &Collection<T>) {2483 // check params2484 assert!(2485 item.decimal_points <= MAX_DECIMAL_POINTS,2486 "decimal_points parameter must be lower than MAX_DECIMAL_POINTS"2487 );2488 assert!(2489 item.name.len() <= 64,2490 "Collection name can not be longer than 63 char"2491 );2492 assert!(2493 item.name.len() <= 256,2494 "Collection description can not be longer than 255 char"2495 );2496 assert!(2497 item.token_prefix.len() <= 16,2498 "Token prefix can not be longer than 15 char"2499 );25002501 // Generate next collection ID2502 let next_id = CreatedCollectionCount::get()2503 .checked_add(1)2504 .unwrap();25052506 CreatedCollectionCount::put(next_id);2507 }25082509 fn init_nft_token(collection_id: CollectionId, item: &NftItemType<T::CrossAccountId>) {2510 let current_index = <ItemListIndex>::get(collection_id)2511 .checked_add(1)2512 .unwrap();25132514 Self::add_token_index(collection_id, current_index, &item.owner).unwrap();25152516 <ItemListIndex>::insert(collection_id, current_index);25172518 // Update balance2519 let new_balance = <Balance<T>>::get(collection_id, item.owner.as_sub())2520 .checked_add(1)2521 .unwrap();2522 <Balance<T>>::insert(collection_id, item.owner.as_sub(), new_balance);2523 }25242525 fn init_fungible_token(collection_id: CollectionId, owner: &T::CrossAccountId, item: &FungibleItemType) {2526 let current_index = <ItemListIndex>::get(collection_id)2527 .checked_add(1)2528 .unwrap();25292530 Self::add_token_index(collection_id, current_index, owner).unwrap();25312532 <ItemListIndex>::insert(collection_id, current_index);25332534 // Update balance2535 let new_balance = <Balance<T>>::get(collection_id, owner.as_sub())2536 .checked_add(item.value)2537 .unwrap();2538 <Balance<T>>::insert(collection_id, owner.as_sub(), new_balance);2539 }25402541 fn init_refungible_token(collection_id: CollectionId, item: &ReFungibleItemType<T::CrossAccountId>) {2542 let current_index = <ItemListIndex>::get(collection_id)2543 .checked_add(1)2544 .unwrap();25452546 let value = item.owner.first().unwrap().fraction;2547 let owner = item.owner.first().unwrap().owner.clone();25482549 Self::add_token_index(collection_id, current_index, &owner).unwrap();25502551 <ItemListIndex>::insert(collection_id, current_index);25522553 // Update balance2554 let new_balance = <Balance<T>>::get(collection_id, &owner.as_sub())2555 .checked_add(value)2556 .unwrap();2557 <Balance<T>>::insert(collection_id, owner.as_sub(), new_balance);2558 }25592560 fn add_token_index(collection_id: CollectionId, item_index: TokenId, owner: &T::CrossAccountId) -> DispatchResult {2561 // add to account limit2562 if <AccountItemCount<T>>::contains_key(owner.as_sub()) {25632564 // bound Owned tokens by a single address2565 let count = <AccountItemCount<T>>::get(owner.as_sub());2566 ensure!(count < ChainLimit::get().account_token_ownership_limit, Error::<T>::AddressOwnershipLimitExceeded);25672568 <AccountItemCount<T>>::insert(owner.as_sub(), count2569 .checked_add(1)2570 .ok_or(Error::<T>::NumOverflow)?);2571 }2572 else {2573 <AccountItemCount<T>>::insert(owner.as_sub(), 1);2574 }25752576 let list_exists = <AddressTokens<T>>::contains_key(collection_id, owner.as_sub());2577 if list_exists {2578 let mut list = <AddressTokens<T>>::get(collection_id, owner.as_sub());2579 let item_contains = list.contains(&item_index.clone());25802581 if !item_contains {2582 list.push(item_index.clone());2583 }25842585 <AddressTokens<T>>::insert(collection_id, owner.as_sub(), list);2586 } else {2587 let mut itm = Vec::new();2588 itm.push(item_index.clone());2589 <AddressTokens<T>>::insert(collection_id, owner.as_sub(), itm);2590 }25912592 Ok(())2593 }25942595 fn remove_token_index(2596 collection_id: CollectionId,2597 item_index: TokenId,2598 owner: &T::CrossAccountId,2599 ) -> DispatchResult {26002601 // update counter2602 <AccountItemCount<T>>::insert(owner.as_sub(), 2603 <AccountItemCount<T>>::get(owner.as_sub())2604 .checked_sub(1)2605 .ok_or(Error::<T>::NumOverflow)?);260626072608 let list_exists = <AddressTokens<T>>::contains_key(collection_id, owner.as_sub());2609 if list_exists {2610 let mut list = <AddressTokens<T>>::get(collection_id, owner.as_sub());2611 let item_contains = list.contains(&item_index.clone());26122613 if item_contains {2614 list.retain(|&item| item != item_index);2615 <AddressTokens<T>>::insert(collection_id, owner.as_sub(), list);2616 }2617 }26182619 Ok(())2620 }26212622 fn move_token_index(2623 collection_id: CollectionId,2624 item_index: TokenId,2625 old_owner: &T::CrossAccountId,2626 new_owner: &T::CrossAccountId,2627 ) -> DispatchResult {2628 Self::remove_token_index(collection_id, item_index, old_owner)?;2629 Self::add_token_index(collection_id, item_index, new_owner)?;26302631 Ok(())2632 }2633 2634 fn ensure_contract_owned(account: T::AccountId, contract: &T::AccountId) -> DispatchResult {2635 ensure!(<ContractOwner<T>>::get(contract) == Some(account), Error::<T>::NoPermission);26362637 Ok(())2638 }2639}26402641////////////////////////////////////////////////////////////////////////////////////////////////////2642// Economic models2643// #region26442645/// Fee multiplier.2646pub type Multiplier = FixedU128;26472648type BalanceOf<T> = <<T as pallet_transaction_payment::Config>::OnChargeTransaction as pallet_transaction_payment::OnChargeTransaction<T>>::Balance;26492650/// Require the transactor pay for themselves and maybe include a tip to gain additional priority2651/// in the queue.2652#[derive(Encode, Decode, Clone, Eq, PartialEq)]2653pub struct ChargeTransactionPayment<T: Config>(#[codec(compact)] BalanceOf<T>);26542655impl<T: Config + Send + Sync> sp_std::fmt::Debug 2656 for ChargeTransactionPayment<T>2657{2658 #[cfg(feature = "std")]2659 fn fmt(&self, f: &mut sp_std::fmt::Formatter) -> sp_std::fmt::Result {2660 write!(f, "ChargeTransactionPayment<{:?}>", self.0)2661 }2662 #[cfg(not(feature = "std"))]2663 fn fmt(&self, _: &mut sp_std::fmt::Formatter) -> sp_std::fmt::Result {2664 Ok(())2665 }2666}26672668impl<T: Config> ChargeTransactionPayment<T>2669where2670 T::Call: Dispatchable<Info=DispatchInfo, PostInfo=PostDispatchInfo> + IsSubType<Call<T>> + IsSubType<pallet_contracts::Call<T>>,2671 BalanceOf<T>: Send + Sync + From<u64> + FixedPointOperand,2672 T::AccountId: AsRef<[u8]>,2673 T::AccountId: UncheckedFrom<T::Hash>,2674{2675 fn traditional_fee(2676 len: usize,2677 info: &DispatchInfoOf<T::Call>,2678 tip: BalanceOf<T>,2679 ) -> BalanceOf<T>2680 where2681 T::Call: Dispatchable<Info = DispatchInfo>,2682 {2683 <pallet_transaction_payment::Module<T>>::compute_fee(len as u32, info, tip)2684 }26852686 fn get_priority(len: usize, info: &DispatchInfoOf<T::Call>, final_fee: BalanceOf<T>) -> TransactionPriority {2687 let weight_saturation = T::BlockWeights::get().max_block / info.weight.max(1);2688 let max_block_length = *T::BlockLength::get().max.get(DispatchClass::Normal);2689 let len_saturation = max_block_length as u64 / (len as u64).max(1);2690 let coefficient: BalanceOf<T> = weight_saturation2691 .min(len_saturation)2692 .saturated_into::<BalanceOf<T>>();2693 final_fee2694 .saturating_mul(coefficient)2695 .saturated_into::<TransactionPriority>()2696 }26972698 fn withdraw_fee(2699 &self,2700 who: &T::AccountId,2701 call: &T::Call,2702 info: &DispatchInfoOf<T::Call>,2703 len: usize,2704 ) -> Result<2705 (2706 BalanceOf<T>,2707 <<T as pallet_transaction_payment::Config>::OnChargeTransaction as pallet_transaction_payment::OnChargeTransaction<T>>::LiquidityInfo,2708 ),2709 TransactionValidityError,2710 > {2711 let tip = self.0;27122713 let fee = Self::traditional_fee(len, info, tip);27142715 // Only mess with balances if fee is not zero.2716 if fee.is_zero() {2717 return <<T as pallet_transaction_payment::Config>::OnChargeTransaction as pallet_transaction_payment::OnChargeTransaction<T>>::withdraw_fee(who, call, info, fee, tip)2718 .map(|i| (fee, i));2719 }27202721 // Determine who is paying transaction fee based on ecnomic model2722 // Parse call to extract collection ID and access collection sponsor2723 let mut sponsor: Option<T::AccountId> = (|| match IsSubType::<Call<T>>::is_sub_type(call) {2724 Some(Call::create_item(collection_id, _owner, _properties)) => {2725 let collection = <CollectionById<T>>::get(collection_id)?;27262727 // sponsor timeout2728 let block_number = <system::Module<T>>::block_number() as T::BlockNumber;27292730 let limit = collection.limits.sponsor_transfer_timeout;2731 if <CreateItemBasket<T>>::contains_key((collection_id, &who)) {2732 let last_tx_block = <CreateItemBasket<T>>::get((collection_id, &who));2733 let limit_time = last_tx_block + limit.into();2734 if block_number <= limit_time {2735 return None;2736 }2737 }2738 <CreateItemBasket<T>>::insert((collection_id, who.clone()), block_number);27392740 // check free create limit2741 if collection.limits.sponsored_data_size >= (_properties.len() as u32) {2742 collection.sponsorship.sponsor()2743 .cloned()2744 } else {2745 None2746 }2747 }2748 Some(Call::transfer(_new_owner, collection_id, item_id, _value)) => {2749 let collection = <CollectionById<T>>::get(collection_id)?;2750 2751 let mut sponsor_transfer = false;2752 if collection.sponsorship.confirmed() {27532754 let collection_limits = collection.limits;2755 let collection_mode = collection.mode;2756 2757 // sponsor timeout2758 let block_number = <system::Module<T>>::block_number() as T::BlockNumber;2759 sponsor_transfer = match collection_mode {2760 CollectionMode::NFT => {2761 2762 // get correct limit2763 let limit: u32 = if collection_limits.sponsor_transfer_timeout > 0 {2764 collection_limits.sponsor_transfer_timeout2765 } else {2766 ChainLimit::get().nft_sponsor_transfer_timeout2767 };2768 2769 let mut sponsored = true;2770 if <NftTransferBasket<T>>::contains_key(collection_id, item_id) {2771 let last_tx_block = <NftTransferBasket<T>>::get(collection_id, item_id);2772 let limit_time = last_tx_block + limit.into();2773 if block_number <= limit_time {2774 sponsored = false;2775 }2776 }2777 if sponsored {2778 <NftTransferBasket<T>>::insert(collection_id, item_id, block_number);2779 }27802781 sponsored2782 }2783 CollectionMode::Fungible(_) => {2784 2785 // get correct limit2786 let limit: u32 = if collection_limits.sponsor_transfer_timeout > 0 {2787 collection_limits.sponsor_transfer_timeout2788 } else {2789 ChainLimit::get().fungible_sponsor_transfer_timeout2790 };2791 2792 let block_number = <system::Module<T>>::block_number() as T::BlockNumber;2793 let mut sponsored = true;2794 if <FungibleTransferBasket<T>>::contains_key(collection_id, who) {2795 let last_tx_block = <FungibleTransferBasket<T>>::get(collection_id, who);2796 let limit_time = last_tx_block + limit.into();2797 if block_number <= limit_time {2798 sponsored = false;2799 }2800 }2801 if sponsored {2802 <FungibleTransferBasket<T>>::insert(collection_id, who, block_number);2803 }28042805 sponsored2806 }2807 CollectionMode::ReFungible => {2808 2809 // get correct limit2810 let limit: u32 = if collection_limits.sponsor_transfer_timeout > 0 {2811 collection_limits.sponsor_transfer_timeout2812 } else {2813 ChainLimit::get().refungible_sponsor_transfer_timeout2814 };2815 2816 let mut sponsored = true;2817 if <ReFungibleTransferBasket<T>>::contains_key(collection_id, item_id) {2818 let last_tx_block = <ReFungibleTransferBasket<T>>::get(collection_id, item_id);2819 let limit_time = last_tx_block + limit.into();2820 if block_number <= limit_time {2821 sponsored = false;2822 }2823 }2824 if sponsored {2825 <ReFungibleTransferBasket<T>>::insert(collection_id, item_id, block_number);2826 }28272828 sponsored2829 }2830 _ => {2831 false2832 },2833 };2834 }28352836 if !sponsor_transfer {2837 None2838 } else {2839 collection.sponsorship.sponsor()2840 .cloned()2841 }2842 }28432844 Some(Call::set_variable_meta_data(collection_id, item_id, data)) => {2845 let mut sponsor_metadata_changes = false;28462847 let collection = <CollectionById<T>>::get(collection_id)?;28482849 if2850 collection.sponsorship.confirmed() &&2851 // Can't sponsor fungible collection, this tx will be rejected2852 // as invalid2853 !matches!(collection.mode, CollectionMode::Fungible(_)) &&2854 data.len() <= collection.limits.sponsored_data_size as usize2855 {2856 if let Some(rate_limit) = collection.limits.sponsored_data_rate_limit {2857 let block_number = <system::Module<T>>::block_number() as T::BlockNumber;28582859 if <VariableMetaDataBasket<T>>::get(collection_id, item_id)2860 .map(|last_block| block_number - last_block > rate_limit)2861 .unwrap_or(true) 2862 {2863 sponsor_metadata_changes = true;2864 <VariableMetaDataBasket<T>>::insert(collection_id, item_id, block_number);2865 }2866 }2867 }28682869 if !sponsor_metadata_changes {2870 None2871 } else {2872 collection.sponsorship.sponsor().cloned()2873 }2874 }28752876 _ => None,2877 })();28782879 match IsSubType::<pallet_contracts::Call<T>>::is_sub_type(call) {2880 Some(pallet_contracts::Call::call(dest, _value, _gas_limit, _data)) => {28812882 let called_contract: T::AccountId = T::Lookup::lookup((*dest).clone()).unwrap_or(T::AccountId::default());28832884 let owned_contract = <ContractOwner<T>>::get(called_contract.clone()).as_ref() == Some(who);2885 let white_list_enabled = <ContractWhiteListEnabled<T>>::contains_key(called_contract.clone());2886 2887 if !owned_contract && white_list_enabled {2888 if !<ContractWhiteList<T>>::contains_key(called_contract.clone(), who) {2889 return Err(InvalidTransaction::Call.into());2890 }2891 }2892 },2893 _ => {},2894 }28952896 // Sponsor smart contracts2897 sponsor = sponsor.or_else(|| match IsSubType::<pallet_contracts::Call<T>>::is_sub_type(call) {28982899 // On instantiation: set the contract owner2900 Some(pallet_contracts::Call::instantiate(_endowment, _gas_limit, code_hash, _data, salt)) => {29012902 let new_contract_address = <pallet_contracts::Module<T>>::contract_address(2903 &who,2904 code_hash,2905 salt,2906 );2907 <ContractOwner<T>>::insert(new_contract_address.clone(), who.clone());29082909 None2910 },29112912 // On instantiation with code: set the contract owner2913 Some(pallet_contracts::Call::instantiate_with_code(_endowment, _gas_limit, _code, _data, _salt)) => {29142915 let new_contract_address = <pallet_contracts::Module<T>>::contract_address(2916 &who,2917 &T::Hashing::hash(&_code),2918 _salt,2919 );29202921 <ContractOwner<T>>::insert(new_contract_address.clone(), who.clone());29222923 None2924 }29252926 // When the contract is called, check if the sponsoring is enabled and pay fees from contract endowment if it is2927 Some(pallet_contracts::Call::call(dest, _value, _gas_limit, _data)) => {29282929 let called_contract: T::AccountId = T::Lookup::lookup((*dest).clone()).unwrap_or(T::AccountId::default());29302931 let mut sponsor_transfer = false;2932 if <ContractSponsoringRateLimit<T>>::contains_key(called_contract.clone()) {2933 let last_tx_block = <ContractSponsorBasket<T>>::get((&called_contract, &who));2934 let block_number = <system::Module<T>>::block_number() as T::BlockNumber;2935 let rate_limit = <ContractSponsoringRateLimit<T>>::get(&called_contract);2936 let limit_time = last_tx_block + rate_limit;29372938 if block_number >= limit_time {2939 <ContractSponsorBasket<T>>::insert((called_contract.clone(), who.clone()), block_number);2940 sponsor_transfer = true;2941 }2942 } else {2943 sponsor_transfer = false;2944 }2945 2946 if sponsor_transfer {2947 if <ContractSelfSponsoring<T>>::contains_key(called_contract.clone()) {2948 if <ContractSelfSponsoring<T>>::get(called_contract.clone()) {2949 return Some(called_contract);2950 }2951 }2952 }29532954 None2955 },29562957 _ => None,2958 });29592960 let who_pays_fee = sponsor.unwrap_or_else(|| who.clone());29612962 <<T as pallet_transaction_payment::Config>::OnChargeTransaction as pallet_transaction_payment::OnChargeTransaction<T>>::withdraw_fee(&who_pays_fee, call, info, fee, tip)2963 .map(|i| (fee, i))2964 }2965}296629672968impl<T: Config + Send + Sync> SignedExtension2969 for ChargeTransactionPayment<T>2970where2971 BalanceOf<T>: Send + Sync + From<u64> + FixedPointOperand,2972 T::Call: Dispatchable<Info = DispatchInfo, PostInfo = PostDispatchInfo> + IsSubType<Call<T>> + IsSubType<pallet_contracts::Call<T>>,2973 T::AccountId: AsRef<[u8]>,2974 T::AccountId: UncheckedFrom<T::Hash>,2975{2976 const IDENTIFIER: &'static str = "ChargeTransactionPayment";2977 type AccountId = T::AccountId;2978 type Call = T::Call;2979 type AdditionalSigned = ();2980 type Pre = (2981 // tip2982 BalanceOf<T>,2983 // who pays fee2984 Self::AccountId,2985 // imbalance resulting from withdrawing the fee2986 <<T as pallet_transaction_payment::Config>::OnChargeTransaction as pallet_transaction_payment::OnChargeTransaction<T>>::LiquidityInfo,2987 );2988 fn additional_signed(&self) -> sp_std::result::Result<(), TransactionValidityError> {2989 Ok(())2990 }29912992 fn validate(2993 &self,2994 who: &Self::AccountId,2995 call: &Self::Call,2996 info: &DispatchInfoOf<Self::Call>,2997 len: usize,2998 ) -> TransactionValidity {2999 let (fee, _) = self.withdraw_fee(who, call, info, len)?;3000 Ok(ValidTransaction {3001 priority: Self::get_priority(len, info, fee),3002 ..Default::default()3003 })3004 }30053006 fn pre_dispatch(3007 self,3008 who: &Self::AccountId,3009 call: &Self::Call,3010 info: &DispatchInfoOf<Self::Call>,3011 len: usize,3012 ) -> Result<Self::Pre, TransactionValidityError> {3013 let (_fee, imbalance) = self.withdraw_fee(who, call, info, len)?;3014 Ok((self.0, who.clone(), imbalance))3015 }30163017 fn post_dispatch(3018 pre: Self::Pre,3019 info: &DispatchInfoOf<Self::Call>,3020 post_info: &PostDispatchInfoOf<Self::Call>,3021 len: usize,3022 _result: &DispatchResult,3023 ) -> Result<(), TransactionValidityError> {3024 let (tip, who, imbalance) = pre;3025 let actual_fee = pallet_transaction_payment::Module::<T>::compute_actual_fee(3026 len as u32,3027 info,3028 post_info,3029 tip,3030 );3031 <T as pallet_transaction_payment::Config>::OnChargeTransaction::correct_and_deposit_fee(&who, info, post_info, actual_fee, tip, imbalance)?;3032 Ok(())3033 }3034}30353036// #endregion30373038sp_api::decl_runtime_apis! {3039 pub trait NftApi {3040 /// Used for ethereum integration3041 fn eth_contract_code(account: H160) -> Option<Vec<u8>>;3042 }3043}runtime/src/lib.rsdiffbeforeafterboth--- a/runtime/src/lib.rs
+++ b/runtime/src/lib.rs
@@ -381,6 +381,7 @@
type Event = Event;
type FindAuthor = EthereumFindAuthor<Aura>;
type StateRoot = pallet_ethereum::IntermediateStateRoot;
+ type EvmSubmitLog = pallet_evm::Module<Runtime>;
}
impl pallet_grandpa::Config for Runtime {
@@ -588,6 +589,9 @@
type Currency = Balances;
type CollectionCreationPrice = CollectionCreationPrice;
type TreasuryAccountId = TreasuryAccountId;
+
+ type EthereumChainId = ChainId;
+ type EthereumTransactionSender = pallet_ethereum::Module<Runtime>;
}
construct_runtime!(