difftreelog
feat support evm accounts in chainspec
in: master
2 files changed
node/src/chain_spec.rsdiffbeforeafterboth--- a/node/src/chain_spec.rs
+++ b/node/src/chain_spec.rs
@@ -179,25 +179,7 @@
.collect(),
},
pallet_nft: NftConfig {
- collection_id: vec![(
- 1,
- Collection {
- owner: get_account_id_from_seed::<sr25519::Public>("Alice"),
- mode: CollectionMode::NFT,
- access: AccessMode::Normal,
- decimal_points: 0,
- name: vec![],
- description: vec![],
- token_prefix: vec![],
- mint_mode: false,
- offchain_schema: vec![],
- schema_version: SchemaVersion::default(),
- sponsorship: SponsorshipState::Confirmed(get_account_id_from_seed::<sr25519::Public>("Alice")),
- const_on_chain_schema: vec![],
- variable_on_chain_schema: vec![],
- limits: CollectionLimits::default()
- },
- )],
+ collection_id: vec![],
nft_item_id: vec![],
fungible_item_id: vec![],
refungible_item_id: vec![],
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, account_id, 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::AccountId>) {2416 let current_index = <ItemListIndex>::get(collection_id)2417 .checked_add(1)2418 .unwrap();24192420 let item_owner = item.owner.clone();2421 Self::add_token_index(collection_id, current_index, &item.owner).unwrap();24222423 <ItemListIndex>::insert(collection_id, current_index);24242425 // Update balance2426 let new_balance = <Balance<T>>::get(collection_id, &item_owner)2427 .checked_add(1)2428 .unwrap();2429 <Balance<T>>::insert(collection_id, item_owner.clone(), new_balance);2430 }24312432 fn init_fungible_token(collection_id: CollectionId, owner: &T::AccountId, item: &FungibleItemType) {2433 let current_index = <ItemListIndex>::get(collection_id)2434 .checked_add(1)2435 .unwrap();24362437 Self::add_token_index(collection_id, current_index, owner).unwrap();24382439 <ItemListIndex>::insert(collection_id, current_index);24402441 // Update balance2442 let new_balance = <Balance<T>>::get(collection_id, owner)2443 .checked_add(item.value)2444 .unwrap();2445 <Balance<T>>::insert(collection_id, (*owner).clone(), new_balance);2446 }24472448 fn init_refungible_token(collection_id: CollectionId, item: &ReFungibleItemType<T::AccountId>) {2449 let current_index = <ItemListIndex>::get(collection_id)2450 .checked_add(1)2451 .unwrap();24522453 let value = item.owner.first().unwrap().fraction;2454 let owner = item.owner.first().unwrap().owner.clone();24552456 Self::add_token_index(collection_id, current_index, &owner).unwrap();24572458 <ItemListIndex>::insert(collection_id, current_index);24592460 // Update balance2461 let new_balance = <Balance<T>>::get(collection_id, &owner)2462 .checked_add(value)2463 .unwrap();2464 <Balance<T>>::insert(collection_id, owner.clone(), new_balance);2465 }24662467 fn add_token_index(collection_id: CollectionId, item_index: TokenId, owner: &T::AccountId) -> DispatchResult {2468 // add to account limit2469 if <AccountItemCount<T>>::contains_key(owner) {24702471 // bound Owned tokens by a single address2472 let count = <AccountItemCount<T>>::get(owner);2473 ensure!(count < ChainLimit::get().account_token_ownership_limit, Error::<T>::AddressOwnershipLimitExceeded);24742475 <AccountItemCount<T>>::insert(owner.clone(), count2476 .checked_add(1)2477 .ok_or(Error::<T>::NumOverflow)?);2478 }2479 else {2480 <AccountItemCount<T>>::insert(owner.clone(), 1);2481 }24822483 let list_exists = <AddressTokens<T>>::contains_key(collection_id, owner);2484 if list_exists {2485 let mut list = <AddressTokens<T>>::get(collection_id, owner);2486 let item_contains = list.contains(&item_index.clone());24872488 if !item_contains {2489 list.push(item_index.clone());2490 }24912492 <AddressTokens<T>>::insert(collection_id, owner.clone(), list);2493 } else {2494 let mut itm = Vec::new();2495 itm.push(item_index.clone());2496 <AddressTokens<T>>::insert(collection_id, owner.clone(), itm);2497 }24982499 Ok(())2500 }25012502 fn remove_token_index(2503 collection_id: CollectionId,2504 item_index: TokenId,2505 owner: &T::AccountId,2506 ) -> DispatchResult {25072508 // update counter2509 <AccountItemCount<T>>::insert(owner.clone(), 2510 <AccountItemCount<T>>::get(owner)2511 .checked_sub(1)2512 .ok_or(Error::<T>::NumOverflow)?);251325142515 let list_exists = <AddressTokens<T>>::contains_key(collection_id, owner);2516 if list_exists {2517 let mut list = <AddressTokens<T>>::get(collection_id, owner);2518 let item_contains = list.contains(&item_index.clone());25192520 if item_contains {2521 list.retain(|&item| item != item_index);2522 <AddressTokens<T>>::insert(collection_id, owner.clone(), list);2523 }2524 }25252526 Ok(())2527 }25282529 fn move_token_index(2530 collection_id: CollectionId,2531 item_index: TokenId,2532 old_owner: &T::AccountId,2533 new_owner: &T::AccountId,2534 ) -> DispatchResult {2535 Self::remove_token_index(collection_id, item_index, old_owner)?;2536 Self::add_token_index(collection_id, item_index, new_owner)?;25372538 Ok(())2539 }2540 2541 fn ensure_contract_owned(account: T::AccountId, contract: &T::AccountId) -> DispatchResult {2542 ensure!(<ContractOwner<T>>::get(contract) == Some(account), Error::<T>::NoPermission);25432544 Ok(())2545 }2546}25472548////////////////////////////////////////////////////////////////////////////////////////////////////2549// Economic models2550// #region25512552/// Fee multiplier.2553pub type Multiplier = FixedU128;25542555type BalanceOf<T> = <<T as pallet_transaction_payment::Config>::OnChargeTransaction as pallet_transaction_payment::OnChargeTransaction<T>>::Balance;25562557/// Require the transactor pay for themselves and maybe include a tip to gain additional priority2558/// in the queue.2559#[derive(Encode, Decode, Clone, Eq, PartialEq)]2560pub struct ChargeTransactionPayment<T: Config>(#[codec(compact)] BalanceOf<T>);25612562impl<T: Config + Send + Sync> sp_std::fmt::Debug 2563 for ChargeTransactionPayment<T>2564{2565 #[cfg(feature = "std")]2566 fn fmt(&self, f: &mut sp_std::fmt::Formatter) -> sp_std::fmt::Result {2567 write!(f, "ChargeTransactionPayment<{:?}>", self.0)2568 }2569 #[cfg(not(feature = "std"))]2570 fn fmt(&self, _: &mut sp_std::fmt::Formatter) -> sp_std::fmt::Result {2571 Ok(())2572 }2573}25742575impl<T: Config> ChargeTransactionPayment<T>2576where2577 T::Call: Dispatchable<Info=DispatchInfo, PostInfo=PostDispatchInfo> + IsSubType<Call<T>> + IsSubType<pallet_contracts::Call<T>>,2578 BalanceOf<T>: Send + Sync + From<u64> + FixedPointOperand,2579 T::AccountId: AsRef<[u8]>,2580 T::AccountId: UncheckedFrom<T::Hash>,2581{2582 fn traditional_fee(2583 len: usize,2584 info: &DispatchInfoOf<T::Call>,2585 tip: BalanceOf<T>,2586 ) -> BalanceOf<T>2587 where2588 T::Call: Dispatchable<Info = DispatchInfo>,2589 {2590 <pallet_transaction_payment::Module<T>>::compute_fee(len as u32, info, tip)2591 }25922593 fn get_priority(len: usize, info: &DispatchInfoOf<T::Call>, final_fee: BalanceOf<T>) -> TransactionPriority {2594 let weight_saturation = T::BlockWeights::get().max_block / info.weight.max(1);2595 let max_block_length = *T::BlockLength::get().max.get(DispatchClass::Normal);2596 let len_saturation = max_block_length as u64 / (len as u64).max(1);2597 let coefficient: BalanceOf<T> = weight_saturation2598 .min(len_saturation)2599 .saturated_into::<BalanceOf<T>>();2600 final_fee2601 .saturating_mul(coefficient)2602 .saturated_into::<TransactionPriority>()2603 }26042605 fn withdraw_fee(2606 &self,2607 who: &T::AccountId,2608 call: &T::Call,2609 info: &DispatchInfoOf<T::Call>,2610 len: usize,2611 ) -> Result<2612 (2613 BalanceOf<T>,2614 <<T as pallet_transaction_payment::Config>::OnChargeTransaction as pallet_transaction_payment::OnChargeTransaction<T>>::LiquidityInfo,2615 ),2616 TransactionValidityError,2617 > {2618 let tip = self.0;26192620 let fee = Self::traditional_fee(len, info, tip);26212622 // Only mess with balances if fee is not zero.2623 if fee.is_zero() {2624 return <<T as pallet_transaction_payment::Config>::OnChargeTransaction as pallet_transaction_payment::OnChargeTransaction<T>>::withdraw_fee(who, call, info, fee, tip)2625 .map(|i| (fee, i));2626 }26272628 // Determine who is paying transaction fee based on ecnomic model2629 // Parse call to extract collection ID and access collection sponsor2630 let mut sponsor: Option<T::AccountId> = (|| match IsSubType::<Call<T>>::is_sub_type(call) {2631 Some(Call::create_item(collection_id, _owner, _properties)) => {2632 let collection = <CollectionById<T>>::get(collection_id)?;26332634 // sponsor timeout2635 let block_number = <system::Module<T>>::block_number() as T::BlockNumber;26362637 let limit = collection.limits.sponsor_transfer_timeout;2638 if <CreateItemBasket<T>>::contains_key((collection_id, &who)) {2639 let last_tx_block = <CreateItemBasket<T>>::get((collection_id, &who));2640 let limit_time = last_tx_block + limit.into();2641 if block_number <= limit_time {2642 return None;2643 }2644 }2645 <CreateItemBasket<T>>::insert((collection_id, who.clone()), block_number);26462647 // check free create limit2648 if collection.limits.sponsored_data_size >= (_properties.len() as u32) {2649 collection.sponsorship.sponsor()2650 .cloned()2651 } else {2652 None2653 }2654 }2655 Some(Call::transfer(_new_owner, collection_id, item_id, _value)) => {2656 let collection = <CollectionById<T>>::get(collection_id)?;2657 2658 let mut sponsor_transfer = false;2659 if collection.sponsorship.confirmed() {26602661 let collection_limits = collection.limits;2662 let collection_mode = collection.mode;2663 2664 // sponsor timeout2665 let block_number = <system::Module<T>>::block_number() as T::BlockNumber;2666 sponsor_transfer = match collection_mode {2667 CollectionMode::NFT => {2668 2669 // get correct limit2670 let limit: u32 = if collection_limits.sponsor_transfer_timeout > 0 {2671 collection_limits.sponsor_transfer_timeout2672 } else {2673 ChainLimit::get().nft_sponsor_transfer_timeout2674 };2675 2676 let mut sponsored = true;2677 if <NftTransferBasket<T>>::contains_key(collection_id, item_id) {2678 let last_tx_block = <NftTransferBasket<T>>::get(collection_id, item_id);2679 let limit_time = last_tx_block + limit.into();2680 if block_number <= limit_time {2681 sponsored = false;2682 }2683 }2684 if sponsored {2685 <NftTransferBasket<T>>::insert(collection_id, item_id, block_number);2686 }26872688 sponsored2689 }2690 CollectionMode::Fungible(_) => {2691 2692 // get correct limit2693 let limit: u32 = if collection_limits.sponsor_transfer_timeout > 0 {2694 collection_limits.sponsor_transfer_timeout2695 } else {2696 ChainLimit::get().fungible_sponsor_transfer_timeout2697 };2698 2699 let block_number = <system::Module<T>>::block_number() as T::BlockNumber;2700 let mut sponsored = true;2701 if <FungibleTransferBasket<T>>::contains_key(collection_id, who) {2702 let last_tx_block = <FungibleTransferBasket<T>>::get(collection_id, who);2703 let limit_time = last_tx_block + limit.into();2704 if block_number <= limit_time {2705 sponsored = false;2706 }2707 }2708 if sponsored {2709 <FungibleTransferBasket<T>>::insert(collection_id, who, block_number);2710 }27112712 sponsored2713 }2714 CollectionMode::ReFungible => {2715 2716 // get correct limit2717 let limit: u32 = if collection_limits.sponsor_transfer_timeout > 0 {2718 collection_limits.sponsor_transfer_timeout2719 } else {2720 ChainLimit::get().refungible_sponsor_transfer_timeout2721 };2722 2723 let mut sponsored = true;2724 if <ReFungibleTransferBasket<T>>::contains_key(collection_id, item_id) {2725 let last_tx_block = <ReFungibleTransferBasket<T>>::get(collection_id, item_id);2726 let limit_time = last_tx_block + limit.into();2727 if block_number <= limit_time {2728 sponsored = false;2729 }2730 }2731 if sponsored {2732 <ReFungibleTransferBasket<T>>::insert(collection_id, item_id, block_number);2733 }27342735 sponsored2736 }2737 _ => {2738 false2739 },2740 };2741 }27422743 if !sponsor_transfer {2744 None2745 } else {2746 collection.sponsorship.sponsor()2747 .cloned()2748 }2749 }27502751 Some(Call::set_variable_meta_data(collection_id, item_id, data)) => {2752 let mut sponsor_metadata_changes = false;27532754 let collection = <CollectionById<T>>::get(collection_id)?;27552756 if2757 collection.sponsorship.confirmed() &&2758 // Can't sponsor fungible collection, this tx will be rejected2759 // as invalid2760 !matches!(collection.mode, CollectionMode::Fungible(_)) &&2761 data.len() <= collection.limits.sponsored_data_size as usize2762 {2763 if let Some(rate_limit) = collection.limits.sponsored_data_rate_limit {2764 let block_number = <system::Module<T>>::block_number() as T::BlockNumber;27652766 if <VariableMetaDataBasket<T>>::get(collection_id, item_id)2767 .map(|last_block| block_number - last_block > rate_limit)2768 .unwrap_or(true) 2769 {2770 sponsor_metadata_changes = true;2771 <VariableMetaDataBasket<T>>::insert(collection_id, item_id, block_number);2772 }2773 }2774 }27752776 if !sponsor_metadata_changes {2777 None2778 } else {2779 collection.sponsorship.sponsor().cloned()2780 }2781 }27822783 _ => None,2784 })();27852786 match IsSubType::<pallet_contracts::Call<T>>::is_sub_type(call) {2787 Some(pallet_contracts::Call::call(dest, _value, _gas_limit, _data)) => {27882789 let called_contract: T::AccountId = T::Lookup::lookup((*dest).clone()).unwrap_or(T::AccountId::default());27902791 let owned_contract = <ContractOwner<T>>::get(called_contract.clone()).as_ref() == Some(who);2792 let white_list_enabled = <ContractWhiteListEnabled<T>>::contains_key(called_contract.clone());2793 2794 if !owned_contract && white_list_enabled {2795 if !<ContractWhiteList<T>>::contains_key(called_contract.clone(), who) {2796 return Err(InvalidTransaction::Call.into());2797 }2798 }2799 },2800 _ => {},2801 }28022803 // Sponsor smart contracts2804 sponsor = sponsor.or_else(|| match IsSubType::<pallet_contracts::Call<T>>::is_sub_type(call) {28052806 // On instantiation: set the contract owner2807 Some(pallet_contracts::Call::instantiate(_endowment, _gas_limit, code_hash, _data, salt)) => {28082809 let new_contract_address = <pallet_contracts::Module<T>>::contract_address(2810 &who,2811 code_hash,2812 salt,2813 );2814 <ContractOwner<T>>::insert(new_contract_address.clone(), who.clone());28152816 None2817 },28182819 // On instantiation with code: set the contract owner2820 Some(pallet_contracts::Call::instantiate_with_code(_endowment, _gas_limit, _code, _data, _salt)) => {28212822 let new_contract_address = <pallet_contracts::Module<T>>::contract_address(2823 &who,2824 &T::Hashing::hash(&_code),2825 _salt,2826 );28272828 <ContractOwner<T>>::insert(new_contract_address.clone(), who.clone());28292830 None2831 }28322833 // When the contract is called, check if the sponsoring is enabled and pay fees from contract endowment if it is2834 Some(pallet_contracts::Call::call(dest, _value, _gas_limit, _data)) => {28352836 let called_contract: T::AccountId = T::Lookup::lookup((*dest).clone()).unwrap_or(T::AccountId::default());28372838 let mut sponsor_transfer = false;2839 if <ContractSponsoringRateLimit<T>>::contains_key(called_contract.clone()) {2840 let last_tx_block = <ContractSponsorBasket<T>>::get((&called_contract, &who));2841 let block_number = <system::Module<T>>::block_number() as T::BlockNumber;2842 let rate_limit = <ContractSponsoringRateLimit<T>>::get(&called_contract);2843 let limit_time = last_tx_block + rate_limit;28442845 if block_number >= limit_time {2846 <ContractSponsorBasket<T>>::insert((called_contract.clone(), who.clone()), block_number);2847 sponsor_transfer = true;2848 }2849 } else {2850 sponsor_transfer = false;2851 }2852 2853 if sponsor_transfer {2854 if <ContractSelfSponsoring<T>>::contains_key(called_contract.clone()) {2855 if <ContractSelfSponsoring<T>>::get(called_contract.clone()) {2856 return Some(called_contract);2857 }2858 }2859 }28602861 None2862 },28632864 _ => None,2865 });28662867 let who_pays_fee = sponsor.unwrap_or_else(|| who.clone());28682869 <<T as pallet_transaction_payment::Config>::OnChargeTransaction as pallet_transaction_payment::OnChargeTransaction<T>>::withdraw_fee(&who_pays_fee, call, info, fee, tip)2870 .map(|i| (fee, i))2871 }2872}287328742875impl<T: Config + Send + Sync> SignedExtension2876 for ChargeTransactionPayment<T>2877where2878 BalanceOf<T>: Send + Sync + From<u64> + FixedPointOperand,2879 T::Call: Dispatchable<Info = DispatchInfo, PostInfo = PostDispatchInfo> + IsSubType<Call<T>> + IsSubType<pallet_contracts::Call<T>>,2880 T::AccountId: AsRef<[u8]>,2881 T::AccountId: UncheckedFrom<T::Hash>,2882{2883 const IDENTIFIER: &'static str = "ChargeTransactionPayment";2884 type AccountId = T::AccountId;2885 type Call = T::Call;2886 type AdditionalSigned = ();2887 type Pre = (2888 // tip2889 BalanceOf<T>,2890 // who pays fee2891 Self::AccountId,2892 // imbalance resulting from withdrawing the fee2893 <<T as pallet_transaction_payment::Config>::OnChargeTransaction as pallet_transaction_payment::OnChargeTransaction<T>>::LiquidityInfo,2894 );2895 fn additional_signed(&self) -> sp_std::result::Result<(), TransactionValidityError> {2896 Ok(())2897 }28982899 fn validate(2900 &self,2901 who: &Self::AccountId,2902 call: &Self::Call,2903 info: &DispatchInfoOf<Self::Call>,2904 len: usize,2905 ) -> TransactionValidity {2906 let (fee, _) = self.withdraw_fee(who, call, info, len)?;2907 Ok(ValidTransaction {2908 priority: Self::get_priority(len, info, fee),2909 ..Default::default()2910 })2911 }29122913 fn pre_dispatch(2914 self,2915 who: &Self::AccountId,2916 call: &Self::Call,2917 info: &DispatchInfoOf<Self::Call>,2918 len: usize,2919 ) -> Result<Self::Pre, TransactionValidityError> {2920 let (_fee, imbalance) = self.withdraw_fee(who, call, info, len)?;2921 Ok((self.0, who.clone(), imbalance))2922 }29232924 fn post_dispatch(2925 pre: Self::Pre,2926 info: &DispatchInfoOf<Self::Call>,2927 post_info: &PostDispatchInfoOf<Self::Call>,2928 len: usize,2929 _result: &DispatchResult,2930 ) -> Result<(), TransactionValidityError> {2931 let (tip, who, imbalance) = pre;2932 let actual_fee = pallet_transaction_payment::Module::<T>::compute_actual_fee(2933 len as u32,2934 info,2935 post_info,2936 tip,2937 );2938 <T as pallet_transaction_payment::Config>::OnChargeTransaction::correct_and_deposit_fee(&who, info, post_info, actual_fee, tip, imbalance)?;2939 Ok(())2940 }2941}29422943// #endregion29442945sp_api::decl_runtime_apis! {2946 pub trait NftApi {2947 /// Used for ethereum integration2948 fn eth_contract_code(account: H160) -> Option<Vec<u8>>;2949 }2950}