difftreelog
refactor switch to macro-based ERC logs
in: master
2 files changed
pallets/nft/src/eth/log.rsdiffbeforeafterboth--- a/pallets/nft/src/eth/log.rs
+++ b/pallets/nft/src/eth/log.rs
@@ -1,41 +1,19 @@
-use pallet_evm::PrecompileLog;
use sp_std::cell::RefCell;
use sp_std::vec::Vec;
use sp_core::{H160, H256};
+use ethereum::Log;
#[derive(Default)]
-pub struct LogRecorder(RefCell<Vec<(Vec<H256>, Vec<u8>)>>);
+pub struct LogRecorder(RefCell<Vec<Log>>);
impl LogRecorder {
pub fn is_empty(&self) -> bool {
self.0.borrow().is_empty()
}
- pub fn log(&self, topics: Vec<H256>, data: super::abi::AbiWriter) {
- self.0.borrow_mut().push((topics, data.finish()));
- }
- fn retrieve_logs(self) -> Vec<(Vec<H256>, Vec<u8>)> {
- self.0.replace(Vec::new())
+ pub fn log(&self, log: Log) {
+ self.0.borrow_mut().push(log);
}
- pub fn retrieve_logs_for_contract(self, contract: H160) -> Vec<PrecompileLog> {
- // TODO: Remove reallocation
- self.retrieve_logs().into_iter()
- .map(|(topics, data)| PrecompileLog(contract.clone(), topics, data))
- .collect()
- }
-}
-impl Drop for LogRecorder {
- fn drop(&mut self) {
- #[cfg(feature = "std")]
- {
- // In debug mode, log recorder panics if dropped with logs left
- let logs = self.0.borrow();
- if !logs.is_empty() {
- eprintln!("Logs lost:");
- for line in logs.iter() {
- eprintln!("{:?} {:?}", line.0, line.1);
- }
- panic!();
- }
- }
+ pub fn retrieve_logs(self) -> Vec<Log> {
+ self.0.into_inner()
}
}
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)]91011pub use serde::{Serialize, Deserialize};1213use core::ops::{Deref, DerefMut};14use codec::{Decode, Encode};15pub use frame_support::{16 construct_runtime, decl_event, decl_module, decl_storage, decl_error,17 dispatch::DispatchResult,18 ensure, fail, parameter_types,19 traits::{20 Currency, ExistenceRequirement, Get, Imbalance, KeyOwnerProofSystem, OnUnbalanced,21 Randomness, IsSubType, WithdrawReasons,22 },23 weights::{24 constants::{BlockExecutionWeight, ExtrinsicBaseWeight, RocksDbWeight, WEIGHT_PER_SECOND},25 DispatchInfo, GetDispatchInfo, IdentityFee, Pays, PostDispatchInfo, Weight,26 WeightToFeePolynomial, DispatchClass,27 },28 StorageValue,29 transactional,30};3132use frame_system::{self as system, ensure_signed, ensure_root};33use sp_core::{H160, H256};34use sp_runtime::sp_std::prelude::Vec;35use sp_runtime::{36 traits::{37 Hash, DispatchInfoOf, Dispatchable, PostDispatchInfoOf, Saturating, SaturatedConversion, SignedExtension, Zero,38 },39 transaction_validity::{40 TransactionPriority, InvalidTransaction, TransactionValidity, TransactionValidityError, ValidTransaction,41 },42 FixedPointOperand, FixedU128,43};44use sp_runtime::traits::StaticLookup;45use pallet_contracts::chain_extension::UncheckedFrom;46use pallet_ethereum::EthereumTransactionSender;47use pallet_transaction_payment::OnChargeTransaction;4849#[cfg(test)]50mod mock;5152#[cfg(test)]53mod tests;5455mod default_weights;56mod eth;5758pub use eth::NftErcSupport;59pub use eth::account::*;6061pub const MAX_DECIMAL_POINTS: DecimalPoints = 30;62pub const MAX_REFUNGIBLE_PIECES: u128 = 1_000_000_000_000_000_000_000;63pub const MAX_SPONSOR_TIMEOUT: u32 = 10_368_000;64pub const MAX_TOKEN_OWNERSHIP: u32 = 10_000_000;6566// Structs67// #region6869pub type CollectionId = u32;70pub type TokenId = u32;71pub type DecimalPoints = u8;7273#[derive(Encode, Decode, Eq, Debug, Clone, PartialEq)]74#[derive(Serialize, Deserialize)]75pub enum CollectionMode {76 Invalid,77 NFT,78 // decimal points79 Fungible(DecimalPoints),80 ReFungible,81}8283impl Default for CollectionMode {84 fn default() -> Self {85 Self::Invalid86 }87}8889impl Into<u8> for CollectionMode {90 fn into(self) -> u8 {91 match self {92 CollectionMode::Invalid => 0,93 CollectionMode::NFT => 1,94 CollectionMode::Fungible(_) => 2,95 CollectionMode::ReFungible => 3,96 }97 }98}99100#[derive(Encode, Decode, Eq, Debug, Clone, PartialEq)]101#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]102pub enum AccessMode {103 Normal,104 WhiteList,105}106impl Default for AccessMode {107 fn default() -> Self {108 Self::Normal109 }110}111112#[derive(Encode, Decode, Eq, Debug, Clone, PartialEq)]113#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]114pub enum SchemaVersion {115 ImageURL,116 Unique,117}118impl Default for SchemaVersion {119 fn default() -> Self {120 Self::ImageURL121 }122}123124#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]125#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]126pub struct Ownership<AccountId> {127 pub owner: AccountId,128 pub fraction: u128,129}130131#[derive(Encode, Decode, Debug, Clone, PartialEq)]132#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]133pub enum SponsorshipState<AccountId> {134 /// The fees are applied to the transaction sender135 Disabled,136 Unconfirmed(AccountId),137 /// Transactions are sponsored by specified account138 Confirmed(AccountId),139}140141impl<AccountId> SponsorshipState<AccountId> {142 fn sponsor(&self) -> Option<&AccountId> {143 match self {144 Self::Confirmed(sponsor) => Some(sponsor),145 _ => None,146 }147 }148149 fn pending_sponsor(&self) -> Option<&AccountId> {150 match self {151 Self::Unconfirmed(sponsor) | Self::Confirmed(sponsor) => Some(sponsor),152 _ => None,153 }154 }155156 fn confirmed(&self) -> bool {157 matches!(self, Self::Confirmed(_))158 }159}160161impl<T> Default for SponsorshipState<T> {162 fn default() -> Self {163 Self::Disabled164 }165}166167#[derive(Encode, Decode, Clone, PartialEq)]168#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]169pub struct Collection<T: Config> {170 pub owner: T::AccountId,171 pub mode: CollectionMode,172 pub access: AccessMode,173 pub decimal_points: DecimalPoints,174 pub name: Vec<u16>, // 64 include null escape char175 pub description: Vec<u16>, // 256 include null escape char176 pub token_prefix: Vec<u8>, // 16 include null escape char177 pub mint_mode: bool,178 pub offchain_schema: Vec<u8>,179 pub schema_version: SchemaVersion,180 pub sponsorship: SponsorshipState<T::AccountId>,181 pub limits: CollectionLimits<T::BlockNumber>, // Collection private restrictions 182 pub variable_on_chain_schema: Vec<u8>, //183 pub const_on_chain_schema: Vec<u8>, //184}185186pub struct CollectionHandle<T: Config> {187 pub id: CollectionId,188 collection: Collection<T>,189 logs: eth::log::LogRecorder,190}191impl<T: Config> CollectionHandle<T> {192 pub fn get(id: CollectionId) -> Option<Self> {193 <CollectionById<T>>::get(id)194 .map(|collection| Self {195 id,196 collection,197 logs: eth::log::LogRecorder::default(),198 })199 }200 pub fn log(&self, topics: Vec<H256>, data: eth::abi::AbiWriter) {201 self.logs.log(topics, data)202 }203 pub fn into_inner(self) -> Collection<T> {204 self.collection.clone()205 }206}207208impl<T: Config> Deref for CollectionHandle<T> {209 type Target = Collection<T>;210211 fn deref(&self) -> &Self::Target {212 &self.collection213 }214}215216impl<T: Config> DerefMut for CollectionHandle<T> {217 fn deref_mut(&mut self) -> &mut Self::Target {218 &mut self.collection219 }220}221222#[derive(Encode, Decode, Debug, Clone, PartialEq)]223#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]224pub struct NftItemType<AccountId> {225 pub owner: AccountId,226 pub const_data: Vec<u8>,227 pub variable_data: Vec<u8>,228}229230#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]231#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]232pub struct FungibleItemType {233 pub value: u128,234}235236#[derive(Encode, Decode, Debug, Clone, PartialEq)]237#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]238pub struct ReFungibleItemType<AccountId> {239 pub owner: Vec<Ownership<AccountId>>,240 pub const_data: Vec<u8>,241 pub variable_data: Vec<u8>,242}243244// #[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]245// #[cfg_attr(feature = "std", derive(Serialize, Deserialize))]246// pub struct VestingItem<AccountId, Moment> {247// pub sender: AccountId,248// pub recipient: AccountId,249// pub collection_id: CollectionId,250// pub item_id: TokenId,251// pub amount: u64,252// pub vesting_date: Moment,253// }254255#[derive(Encode, Decode, Debug, Clone, PartialEq)]256#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]257pub struct CollectionLimits<BlockNumber: Encode + Decode> {258 pub account_token_ownership_limit: u32,259 pub sponsored_data_size: u32,260 /// None - setVariableMetadata is not sponsored261 /// Some(v) - setVariableMetadata is sponsored 262 /// if there is v block between txs263 pub sponsored_data_rate_limit: Option<BlockNumber>,264 pub token_limit: u32,265266 // Timeouts for item types in passed blocks267 pub sponsor_transfer_timeout: u32,268 pub owner_can_transfer: bool,269 pub owner_can_destroy: bool,270}271272impl<BlockNumber: Encode + Decode> Default for CollectionLimits<BlockNumber> {273 fn default() -> Self {274 Self { 275 account_token_ownership_limit: 10_000_000, 276 token_limit: u32::max_value(),277 sponsored_data_size: u32::MAX, 278 sponsored_data_rate_limit: None,279 sponsor_transfer_timeout: 14400,280 owner_can_transfer: true,281 owner_can_destroy: true282 }283 }284}285286#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]287#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]288pub struct ChainLimits {289 pub collection_numbers_limit: u32,290 pub account_token_ownership_limit: u32,291 pub collections_admins_limit: u64,292 pub custom_data_limit: u32,293294 // Timeouts for item types in passed blocks295 pub nft_sponsor_transfer_timeout: u32,296 pub fungible_sponsor_transfer_timeout: u32,297 pub refungible_sponsor_transfer_timeout: u32,298299 // Schema limits300 pub offchain_schema_limit: u32,301 pub variable_on_chain_schema_limit: u32,302 pub const_on_chain_schema_limit: u32,303}304305pub trait WeightInfo {306 fn create_collection() -> Weight;307 fn destroy_collection() -> Weight;308 fn add_to_white_list() -> Weight;309 fn remove_from_white_list() -> Weight;310 fn set_public_access_mode() -> Weight;311 fn set_mint_permission() -> Weight;312 fn change_collection_owner() -> Weight;313 fn add_collection_admin() -> Weight;314 fn remove_collection_admin() -> Weight;315 fn set_collection_sponsor() -> Weight;316 fn confirm_sponsorship() -> Weight;317 fn remove_collection_sponsor() -> Weight;318 fn create_item(s: usize) -> Weight;319 fn burn_item() -> Weight;320 fn transfer() -> Weight;321 fn approve() -> Weight;322 fn transfer_from() -> Weight;323 fn set_offchain_schema() -> Weight;324 fn set_const_on_chain_schema() -> Weight;325 fn set_variable_on_chain_schema() -> Weight;326 fn set_variable_meta_data() -> Weight;327 fn enable_contract_sponsoring() -> Weight;328 fn set_schema_version() -> Weight;329 fn set_chain_limits() -> Weight;330 fn set_contract_sponsoring_rate_limit() -> Weight;331 fn set_variable_meta_data_sponsoring_rate_limit() -> Weight;332 fn toggle_contract_white_list() -> Weight;333 fn add_to_contract_white_list() -> Weight;334 fn remove_from_contract_white_list() -> Weight;335 fn set_collection_limits() -> Weight;336}337338#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]339#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]340pub struct CreateNftData {341 pub const_data: Vec<u8>,342 pub variable_data: Vec<u8>,343}344345#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]346#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]347pub struct CreateFungibleData {348 pub value: u128,349}350351#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]352#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]353pub struct CreateReFungibleData {354 pub const_data: Vec<u8>,355 pub variable_data: Vec<u8>,356 pub pieces: u128,357}358359#[derive(Encode, Decode, Debug, Clone, PartialEq)]360#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]361pub enum CreateItemData {362 NFT(CreateNftData),363 Fungible(CreateFungibleData),364 ReFungible(CreateReFungibleData),365}366367impl CreateItemData {368 pub fn len(&self) -> usize {369 let len = match self {370 CreateItemData::NFT(data) => data.variable_data.len() + data.const_data.len(),371 CreateItemData::ReFungible(data) => data.variable_data.len() + data.const_data.len(),372 _ => 0373 };374 375 return len;376 }377}378379impl From<CreateNftData> for CreateItemData {380 fn from(item: CreateNftData) -> Self {381 CreateItemData::NFT(item)382 }383}384385impl From<CreateReFungibleData> for CreateItemData {386 fn from(item: CreateReFungibleData) -> Self {387 CreateItemData::ReFungible(item)388 }389}390391impl From<CreateFungibleData> for CreateItemData {392 fn from(item: CreateFungibleData) -> Self {393 CreateItemData::Fungible(item)394 }395}396397398decl_error! {399 /// Error for non-fungible-token module.400 pub enum Error for Module<T: Config> {401 /// Total collections bound exceeded.402 TotalCollectionsLimitExceeded,403 /// Decimal_points parameter must be lower than MAX_DECIMAL_POINTS constant, currently it is 30.404 CollectionDecimalPointLimitExceeded, 405 /// Collection name can not be longer than 63 char.406 CollectionNameLimitExceeded, 407 /// Collection description can not be longer than 255 char.408 CollectionDescriptionLimitExceeded, 409 /// Token prefix can not be longer than 15 char.410 CollectionTokenPrefixLimitExceeded,411 /// This collection does not exist.412 CollectionNotFound,413 /// Item not exists.414 TokenNotFound,415 /// Admin not found416 AdminNotFound,417 /// Arithmetic calculation overflow.418 NumOverflow, 419 /// Account already has admin role.420 AlreadyAdmin, 421 /// You do not own this collection.422 NoPermission,423 /// This address is not set as sponsor, use setCollectionSponsor first.424 ConfirmUnsetSponsorFail,425 /// Collection is not in mint mode.426 PublicMintingNotAllowed,427 /// Sender parameter and item owner must be equal.428 MustBeTokenOwner,429 /// Item balance not enough.430 TokenValueTooLow,431 /// Size of item is too large.432 NftSizeLimitExceeded,433 /// No approve found434 ApproveNotFound,435 /// Requested value more than approved.436 TokenValueNotEnough,437 /// Only approved addresses can call this method.438 ApproveRequired,439 /// Address is not in white list.440 AddresNotInWhiteList,441 /// Number of collection admins bound exceeded.442 CollectionAdminsLimitExceeded,443 /// Owned tokens by a single address bound exceeded.444 AddressOwnershipLimitExceeded,445 /// Length of items properties must be greater than 0.446 EmptyArgument,447 /// const_data exceeded data limit.448 TokenConstDataLimitExceeded,449 /// variable_data exceeded data limit.450 TokenVariableDataLimitExceeded,451 /// Not NFT item data used to mint in NFT collection.452 NotNftDataUsedToMintNftCollectionToken,453 /// Not Fungible item data used to mint in Fungible collection.454 NotFungibleDataUsedToMintFungibleCollectionToken,455 /// Not Re Fungible item data used to mint in Re Fungible collection.456 NotReFungibleDataUsedToMintReFungibleCollectionToken,457 /// Unexpected collection type.458 UnexpectedCollectionType,459 /// Can't store metadata in fungible tokens.460 CantStoreMetadataInFungibleTokens,461 /// Collection token limit exceeded462 CollectionTokenLimitExceeded,463 /// Account token limit exceeded per collection464 AccountTokenLimitExceeded,465 /// Collection limit bounds per collection exceeded466 CollectionLimitBoundsExceeded,467 /// Tried to enable permissions which are only permitted to be disabled468 OwnerPermissionsCantBeReverted,469 /// Schema data size limit bound exceeded470 SchemaDataLimitExceeded,471 /// Maximum refungibility exceeded472 WrongRefungiblePieces,473 /// createRefungible should be called with one owner474 BadCreateRefungibleCall,475 }476}477478pub trait Config: system::Config + Sized + pallet_transaction_payment::Config + pallet_contracts::Config {479 type Event: From<Event<Self>> + Into<<Self as system::Config>::Event>;480481 /// Weight information for extrinsics in this pallet.482 type WeightInfo: WeightInfo;483484 type EvmAddressMapping: pallet_evm::AddressMapping<Self::AccountId>;485 type EvmBackwardsAddressMapping: EvmBackwardsAddressMapping<Self::AccountId>;486 type EvmWithdrawOrigin: pallet_evm::EnsureAddressOrigin<Self::Origin, Success = Self::AccountId>;487488 type CrossAccountId: CrossAccountId<Self::AccountId>;489 type Currency: Currency<Self::AccountId>;490 type CollectionCreationPrice: Get<<<Self as Config>::Currency as Currency<Self::AccountId>>::Balance>;491 type TreasuryAccountId: Get<Self::AccountId>;492493 type EthereumChainId: Get<u64>;494 type EthereumTransactionSender: pallet_ethereum::EthereumTransactionSender;495}496497#[cfg(feature = "runtime-benchmarks")]498mod benchmarking;499500// #endregion501502// # Used definitions503//504// ## User control levels505//506// chain-controlled - key is uncontrolled by user507// i.e autoincrementing index508// can use non-cryptographic hash509// real - key is controlled by user510// but it is hard to generate enough colliding values, i.e owner of signed txs511// can use non-cryptographic hash512// controlled - key is completly controlled by users513// i.e maps with mutable keys514// should use cryptographic hash515//516// ## User control level downgrade reasons517//518// ?1 - chain-controlled -> controlled519// collections/tokens can be destroyed, resulting in massive holes520// ?2 - chain-controlled -> controlled521// same as ?1, but can be only added, resulting in easier exploitation522// ?3 - real -> controlled523// no confirmation required, so addresses can be easily generated524decl_storage! {525 trait Store for Module<T: Config> as Nft {526527 //#region Private members528 /// Id of next collection529 CreatedCollectionCount: u32;530 /// Used for migrations531 ChainVersion: u64;532 /// Id of last collection token533 /// Collection id (controlled?1)534 ItemListIndex: map hasher(blake2_128_concat) CollectionId => TokenId;535 //#endregion536537 //#region Chain limits struct538 pub ChainLimit get(fn chain_limit) config(): ChainLimits;539 //#endregion540541 //#region Bound counters542 /// Amount of collections destroyed, used for total amount tracking with543 /// CreatedCollectionCount544 DestroyedCollectionCount: u32;545 /// Total amount of account owned tokens (NFTs + RFTs + unique fungibles)546 /// Account id (real)547 pub AccountItemCount get(fn account_item_count): map hasher(twox_64_concat) T::AccountId => u32;548 //#endregion549550 //#region Basic collections551 /// Collection info552 /// Collection id (controlled?1)553 pub CollectionById get(fn collection_id) config(): map hasher(blake2_128_concat) CollectionId => Option<Collection<T>> = None;554 /// List of collection admins555 /// Collection id (controlled?2)556 pub AdminList get(fn admin_list_collection): map hasher(blake2_128_concat) CollectionId => Vec<T::CrossAccountId>;557 /// Whitelisted collection users558 /// Collection id (controlled?2), user id (controlled?3)559 pub WhiteList get(fn white_list): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) T::AccountId => bool;560 //#endregion561562 /// How many of collection items user have563 /// Collection id (controlled?2), account id (real)564 pub Balance get(fn balance_count): double_map hasher(blake2_128_concat) CollectionId, hasher(twox_64_concat) T::AccountId => u128;565566 /// Amount of items which spender can transfer out of owners account (via transferFrom)567 /// Collection id (controlled?2), (token id (controlled ?2) + owner account id (real) + spender account id (controlled?3))568 /// TODO: Off chain worker should remove from this map when token gets removed569 pub Allowances get(fn approved): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) (TokenId, T::AccountId, T::AccountId) => u128;570571 //#region Item collections572 /// Collection id (controlled?2), token id (controlled?1)573 pub NftItemList get(fn nft_item_id) config(): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => Option<NftItemType<T::CrossAccountId>>;574 /// Collection id (controlled?2), owner (controlled?2)575 pub FungibleItemList get(fn fungible_item_id) config(): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) T::AccountId => FungibleItemType;576 /// Collection id (controlled?2), token id (controlled?1)577 pub ReFungibleItemList get(fn refungible_item_id) config(): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => Option<ReFungibleItemType<T::CrossAccountId>>;578 //#endregion579580 //#region Index list581 /// Collection id (controlled?2), tokens owner (controlled?2)582 pub AddressTokens get(fn address_tokens): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) T::AccountId => Vec<TokenId>;583 //#endregion584585 //#region Tokens transfer rate limit baskets586 /// (Collection id (controlled?2), who created (real))587 /// TODO: Off chain worker should remove from this map when collection gets removed588 pub CreateItemBasket get(fn create_item_basket): map hasher(blake2_128_concat) (CollectionId, T::AccountId) => T::BlockNumber;589 /// Collection id (controlled?2), token id (controlled?2)590 pub NftTransferBasket get(fn nft_transfer_basket): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => T::BlockNumber;591 /// Collection id (controlled?2), owning user (real)592 pub FungibleTransferBasket get(fn fungible_transfer_basket): double_map hasher(blake2_128_concat) CollectionId, hasher(twox_64_concat) T::AccountId => T::BlockNumber;593 /// Collection id (controlled?2), token id (controlled?2)594 pub ReFungibleTransferBasket get(fn refungible_transfer_basket): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => T::BlockNumber;595 //#endregion596597 /// Variable metadata sponsoring598 /// Collection id (controlled?2), token id (controlled?2)599 pub VariableMetaDataBasket get(fn variable_meta_data_basket): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => Option<T::BlockNumber> = None;600 601 //#region Contract Sponsorship and Ownership602 /// Contract address (real)603 pub ContractOwner get(fn contract_owner): map hasher(twox_64_concat) T::AccountId => Option<T::AccountId>;604 /// Contract address (real)605 pub ContractSelfSponsoring get(fn contract_self_sponsoring): map hasher(twox_64_concat) T::AccountId => bool;606 /// (Contract address(real), caller (real))607 pub ContractSponsorBasket get(fn contract_sponsor_basket): map hasher(twox_64_concat) (T::AccountId, T::AccountId) => T::BlockNumber;608 /// Contract address (real)609 pub ContractSponsoringRateLimit get(fn contract_sponsoring_rate_limit): map hasher(twox_64_concat) T::AccountId => T::BlockNumber;610 /// Contract address (real)611 pub ContractWhiteListEnabled get(fn contract_white_list_enabled): map hasher(twox_64_concat) T::AccountId => bool; 612 /// Contract address (real) => Whitelisted user (controlled?3)613 pub ContractWhiteList get(fn contract_white_list): double_map hasher(twox_64_concat) T::AccountId, hasher(blake2_128_concat) T::AccountId => bool; 614 //#endregion615 }616 add_extra_genesis {617 build(|config: &GenesisConfig<T>| {618 // Modification of storage619 for (_num, _c) in &config.collection_id {620 <Module<T>>::init_collection(_c);621 }622623 for (_num, _c, _i) in &config.nft_item_id {624 <Module<T>>::init_nft_token(*_c, _i);625 }626627 for (collection_id, account_id, fungible_item) in &config.fungible_item_id {628 <Module<T>>::init_fungible_token(*collection_id, &T::CrossAccountId::from_sub(account_id.clone()), fungible_item);629 }630631 for (_num, _c, _i) in &config.refungible_item_id {632 <Module<T>>::init_refungible_token(*_c, _i);633 }634 })635 }636}637638decl_event!(639 pub enum Event<T>640 where641 AccountId = <T as frame_system::Config>::AccountId,642 CrossAccountId = <T as Config>::CrossAccountId,643 {644 /// New collection was created645 /// 646 /// # Arguments647 /// 648 /// * collection_id: Globally unique identifier of newly created collection.649 /// 650 /// * mode: [CollectionMode] converted into u8.651 /// 652 /// * account_id: Collection owner.653 CollectionCreated(CollectionId, u8, AccountId),654655 /// New item was created.656 /// 657 /// # Arguments658 /// 659 /// * collection_id: Id of the collection where item was created.660 /// 661 /// * item_id: Id of an item. Unique within the collection.662 ///663 /// * recipient: Owner of newly created item 664 ItemCreated(CollectionId, TokenId, CrossAccountId),665666 /// Collection item was burned.667 /// 668 /// # Arguments669 /// 670 /// collection_id.671 /// 672 /// item_id: Identifier of burned NFT.673 ItemDestroyed(CollectionId, TokenId),674675 /// Item was transferred676 ///677 /// * collection_id: Id of collection to which item is belong678 ///679 /// * item_id: Id of an item680 ///681 /// * sender: Original owner of item682 ///683 /// * recipient: New owner of item684 ///685 /// * amount: Always 1 for NFT686 Transfer(CollectionId, TokenId, CrossAccountId, CrossAccountId, u128),687688 /// * collection_id689 ///690 /// * item_id691 ///692 /// * sender693 ///694 /// * spender695 ///696 /// * amount697 Approved(CollectionId, TokenId, CrossAccountId, CrossAccountId, u128),698 }699);700701decl_module! {702 pub struct Module<T: Config> for enum Call 703 where 704 origin: T::Origin705 {706 fn deposit_event() = default;707 type Error = Error<T>;708709 fn on_initialize(now: T::BlockNumber) -> Weight {710 0711 }712713 /// 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.714 /// 715 /// # Permissions716 /// 717 /// * Anyone.718 /// 719 /// # Arguments720 /// 721 /// * collection_name: UTF-16 string with collection name (limit 64 characters), will be stored as zero-terminated.722 /// 723 /// * collection_description: UTF-16 string with collection description (limit 256 characters), will be stored as zero-terminated.724 /// 725 /// * token_prefix: UTF-8 string with token prefix.726 /// 727 /// * mode: [CollectionMode] collection type and type dependent data.728 // returns collection ID729 #[weight = <T as Config>::WeightInfo::create_collection()]730 #[transactional]731 pub fn create_collection(origin,732 collection_name: Vec<u16>,733 collection_description: Vec<u16>,734 token_prefix: Vec<u8>,735 mode: CollectionMode) -> DispatchResult {736737 // Anyone can create a collection738 let who = ensure_signed(origin)?;739740 // Take a (non-refundable) deposit of collection creation741 let mut imbalance = <<<T as Config>::Currency as Currency<T::AccountId>>::PositiveImbalance>::zero();742 imbalance.subsume(<<T as Config>::Currency as Currency<T::AccountId>>::deposit_creating(743 &T::TreasuryAccountId::get(),744 T::CollectionCreationPrice::get(),745 ));746 <T as Config>::Currency::settle(747 &who,748 imbalance,749 WithdrawReasons::TRANSFER,750 ExistenceRequirement::KeepAlive,751 ).map_err(|_| Error::<T>::NoPermission)?;752753 let decimal_points = match mode {754 CollectionMode::Fungible(points) => points,755 _ => 0756 };757758 let chain_limit = ChainLimit::get();759760 let created_count = CreatedCollectionCount::get();761 let destroyed_count = DestroyedCollectionCount::get();762763 // bound Total number of collections764 ensure!(created_count - destroyed_count < chain_limit.collection_numbers_limit, Error::<T>::TotalCollectionsLimitExceeded);765766 // check params767 ensure!(decimal_points <= MAX_DECIMAL_POINTS, Error::<T>::CollectionDecimalPointLimitExceeded);768 ensure!(collection_name.len() <= 64, Error::<T>::CollectionNameLimitExceeded);769 ensure!(collection_description.len() <= 256, Error::<T>::CollectionDescriptionLimitExceeded);770 ensure!(token_prefix.len() <= 16, Error::<T>::CollectionTokenPrefixLimitExceeded);771772 // Generate next collection ID773 let next_id = created_count774 .checked_add(1)775 .ok_or(Error::<T>::NumOverflow)?;776777 CreatedCollectionCount::put(next_id);778779 let limits = CollectionLimits {780 sponsored_data_size: chain_limit.custom_data_limit,781 ..Default::default()782 };783784 // Create new collection785 let new_collection = Collection {786 owner: who.clone(),787 name: collection_name,788 mode: mode.clone(),789 mint_mode: false,790 access: AccessMode::Normal,791 description: collection_description,792 decimal_points: decimal_points,793 token_prefix: token_prefix,794 offchain_schema: Vec::new(),795 schema_version: SchemaVersion::ImageURL,796 sponsorship: SponsorshipState::Disabled,797 variable_on_chain_schema: Vec::new(),798 const_on_chain_schema: Vec::new(),799 limits,800 };801802 // Add new collection to map803 <CollectionById<T>>::insert(next_id, new_collection);804805 // call event806 Self::deposit_event(RawEvent::CollectionCreated(next_id, mode.into(), who));807808 Ok(())809 }810811 /// **DANGEROUS**: Destroys collection and all NFTs within this collection. Users irrecoverably lose their assets and may lose real money.812 /// 813 /// # Permissions814 /// 815 /// * Collection Owner.816 /// 817 /// # Arguments818 /// 819 /// * collection_id: collection to destroy.820 #[weight = <T as Config>::WeightInfo::destroy_collection()]821 #[transactional]822 pub fn destroy_collection(origin, collection_id: CollectionId) -> DispatchResult {823824 let sender = ensure_signed(origin)?;825 let collection = Self::get_collection(collection_id)?;826 Self::check_owner_permissions(&collection, &sender)?;827 if !collection.limits.owner_can_destroy {828 fail!(Error::<T>::NoPermission);829 }830831 <AddressTokens<T>>::remove_prefix(collection_id);832 <Allowances<T>>::remove_prefix(collection_id);833 <Balance<T>>::remove_prefix(collection_id);834 <ItemListIndex>::remove(collection_id);835 <AdminList<T>>::remove(collection_id);836 <CollectionById<T>>::remove(collection_id);837 <WhiteList<T>>::remove_prefix(collection_id);838839 <NftItemList<T>>::remove_prefix(collection_id);840 <FungibleItemList<T>>::remove_prefix(collection_id);841 <ReFungibleItemList<T>>::remove_prefix(collection_id);842843 <NftTransferBasket<T>>::remove_prefix(collection_id);844 <FungibleTransferBasket<T>>::remove_prefix(collection_id);845 <ReFungibleTransferBasket<T>>::remove_prefix(collection_id);846847 <VariableMetaDataBasket<T>>::remove_prefix(collection_id);848849 DestroyedCollectionCount::put(DestroyedCollectionCount::get()850 .checked_add(1)851 .ok_or(Error::<T>::NumOverflow)?);852853 Ok(())854 }855856 /// Add an address to white list.857 /// 858 /// # Permissions859 /// 860 /// * Collection Owner861 /// * Collection Admin862 /// 863 /// # Arguments864 /// 865 /// * collection_id.866 /// 867 /// * address.868 #[weight = <T as Config>::WeightInfo::add_to_white_list()]869 #[transactional]870 pub fn add_to_white_list(origin, collection_id: CollectionId, address: T::CrossAccountId) -> DispatchResult{871872 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);873 let collection = Self::get_collection(collection_id)?;874875 Self::toggle_white_list_internal(876 &sender,877 &collection,878 &address,879 true,880 )?;881882 Ok(())883 }884885 /// Remove an address from white list.886 /// 887 /// # Permissions888 /// 889 /// * Collection Owner890 /// * Collection Admin891 /// 892 /// # Arguments893 /// 894 /// * collection_id.895 /// 896 /// * address.897 #[weight = <T as Config>::WeightInfo::remove_from_white_list()]898 #[transactional]899 pub fn remove_from_white_list(origin, collection_id: CollectionId, address: T::CrossAccountId) -> DispatchResult{900901 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);902 let collection = Self::get_collection(collection_id)?;903904 Self::toggle_white_list_internal(905 &sender,906 &collection,907 &address,908 false,909 )?;910911 Ok(())912 }913914 /// Toggle between normal and white list access for the methods with access for `Anyone`.915 /// 916 /// # Permissions917 /// 918 /// * Collection Owner.919 /// 920 /// # Arguments921 /// 922 /// * collection_id.923 /// 924 /// * mode: [AccessMode]925 #[weight = <T as Config>::WeightInfo::set_public_access_mode()]926 #[transactional]927 pub fn set_public_access_mode(origin, collection_id: CollectionId, mode: AccessMode) -> DispatchResult928 {929 let sender = ensure_signed(origin)?;930931 let mut target_collection = Self::get_collection(collection_id)?;932 Self::check_owner_permissions(&target_collection, &sender)?;933 target_collection.access = mode;934 Self::save_collection(target_collection);935936 Ok(())937 }938939 /// Allows Anyone to create tokens if:940 /// * White List is enabled, and941 /// * Address is added to white list, and942 /// * This method was called with True parameter943 /// 944 /// # Permissions945 /// * Collection Owner946 ///947 /// # Arguments948 /// 949 /// * collection_id.950 /// 951 /// * mint_permission: Boolean parameter. If True, allows minting to Anyone with conditions above.952 #[weight = <T as Config>::WeightInfo::set_mint_permission()]953 #[transactional]954 pub fn set_mint_permission(origin, collection_id: CollectionId, mint_permission: bool) -> DispatchResult955 {956 let sender = ensure_signed(origin)?;957958 let mut target_collection = Self::get_collection(collection_id)?;959 Self::check_owner_permissions(&target_collection, &sender)?;960 target_collection.mint_mode = mint_permission;961 Self::save_collection(target_collection);962963 Ok(())964 }965966 /// Change the owner of the collection.967 /// 968 /// # Permissions969 /// 970 /// * Collection Owner.971 /// 972 /// # Arguments973 /// 974 /// * collection_id.975 /// 976 /// * new_owner.977 #[weight = <T as Config>::WeightInfo::change_collection_owner()]978 #[transactional]979 pub fn change_collection_owner(origin, collection_id: CollectionId, new_owner: T::AccountId) -> DispatchResult {980981 let sender = ensure_signed(origin)?;982 let mut target_collection = Self::get_collection(collection_id)?;983 Self::check_owner_permissions(&target_collection, &sender)?;984 target_collection.owner = new_owner;985 Self::save_collection(target_collection);986987 Ok(())988 }989990 /// Adds an admin of the Collection.991 /// 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. 992 /// 993 /// # Permissions994 /// 995 /// * Collection Owner.996 /// * Collection Admin.997 /// 998 /// # Arguments999 /// 1000 /// * collection_id: ID of the Collection to add admin for.1001 /// 1002 /// * new_admin_id: Address of new admin to add.1003 #[weight = <T as Config>::WeightInfo::add_collection_admin()]1004 #[transactional]1005 pub fn add_collection_admin(origin, collection_id: CollectionId, new_admin_id: T::CrossAccountId) -> DispatchResult {1006 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1007 let collection = Self::get_collection(collection_id)?;1008 Self::check_owner_or_admin_permissions(&collection, &sender)?;1009 let mut admin_arr = <AdminList<T>>::get(collection_id);10101011 match admin_arr.binary_search(&new_admin_id) {1012 Ok(_) => {},1013 Err(idx) => {1014 let limits = ChainLimit::get();1015 ensure!(admin_arr.len() < limits.collections_admins_limit as usize, Error::<T>::CollectionAdminsLimitExceeded);1016 admin_arr.insert(idx, new_admin_id);1017 <AdminList<T>>::insert(collection_id, admin_arr);1018 }1019 }1020 Ok(())1021 }10221023 /// 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.1024 ///1025 /// # Permissions1026 /// 1027 /// * Collection Owner.1028 /// * Collection Admin.1029 /// 1030 /// # Arguments1031 /// 1032 /// * collection_id: ID of the Collection to remove admin for.1033 /// 1034 /// * account_id: Address of admin to remove.1035 #[weight = <T as Config>::WeightInfo::remove_collection_admin()]1036 #[transactional]1037 pub fn remove_collection_admin(origin, collection_id: CollectionId, account_id: T::CrossAccountId) -> DispatchResult {1038 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1039 let collection = Self::get_collection(collection_id)?;1040 Self::check_owner_or_admin_permissions(&collection, &sender)?;1041 let mut admin_arr = <AdminList<T>>::get(collection_id);10421043 match admin_arr.binary_search(&account_id) {1044 Ok(idx) => {1045 admin_arr.remove(idx);1046 <AdminList<T>>::insert(collection_id, admin_arr);1047 },1048 Err(_) => {}1049 }1050 Ok(())1051 }10521053 /// # Permissions1054 /// 1055 /// * Collection Owner1056 /// 1057 /// # Arguments1058 /// 1059 /// * collection_id.1060 /// 1061 /// * new_sponsor.1062 #[weight = <T as Config>::WeightInfo::set_collection_sponsor()]1063 #[transactional]1064 pub fn set_collection_sponsor(origin, collection_id: CollectionId, new_sponsor: T::AccountId) -> DispatchResult {1065 let sender = ensure_signed(origin)?;1066 let mut target_collection = Self::get_collection(collection_id)?;1067 Self::check_owner_permissions(&target_collection, &sender)?;10681069 target_collection.sponsorship = SponsorshipState::Unconfirmed(new_sponsor);1070 Self::save_collection(target_collection);10711072 Ok(())1073 }10741075 /// # Permissions1076 /// 1077 /// * Sponsor.1078 /// 1079 /// # Arguments1080 /// 1081 /// * collection_id.1082 #[weight = <T as Config>::WeightInfo::confirm_sponsorship()]1083 #[transactional]1084 pub fn confirm_sponsorship(origin, collection_id: CollectionId) -> DispatchResult {1085 let sender = ensure_signed(origin)?;10861087 let mut target_collection = Self::get_collection(collection_id)?;1088 ensure!(1089 target_collection.sponsorship.pending_sponsor() == Some(&sender),1090 Error::<T>::ConfirmUnsetSponsorFail1091 );10921093 target_collection.sponsorship = SponsorshipState::Confirmed(sender);1094 Self::save_collection(target_collection);10951096 Ok(())1097 }10981099 /// Switch back to pay-per-own-transaction model.1100 ///1101 /// # Permissions1102 ///1103 /// * Collection owner.1104 /// 1105 /// # Arguments1106 /// 1107 /// * collection_id.1108 #[weight = <T as Config>::WeightInfo::remove_collection_sponsor()]1109 #[transactional]1110 pub fn remove_collection_sponsor(origin, collection_id: CollectionId) -> DispatchResult {1111 let sender = ensure_signed(origin)?;11121113 let mut target_collection = Self::get_collection(collection_id)?;1114 Self::check_owner_permissions(&target_collection, &sender)?;11151116 target_collection.sponsorship = SponsorshipState::Disabled;1117 Self::save_collection(target_collection);11181119 Ok(())1120 }11211122 /// This method creates a concrete instance of NFT Collection created with CreateCollection method.1123 /// 1124 /// # Permissions1125 /// 1126 /// * Collection Owner.1127 /// * Collection Admin.1128 /// * Anyone if1129 /// * White List is enabled, and1130 /// * Address is added to white list, and1131 /// * MintPermission is enabled (see SetMintPermission method)1132 /// 1133 /// # Arguments1134 /// 1135 /// * collection_id: ID of the collection.1136 /// 1137 /// * owner: Address, initial owner of the NFT.1138 ///1139 /// * data: Token data to store on chain.1140 // #[weight =1141 // (130_000_000 as Weight)1142 // .saturating_add((2135 as Weight).saturating_mul((properties.len() as u64) as Weight))1143 // .saturating_add(RocksDbWeight::get().reads(10 as Weight))1144 // .saturating_add(RocksDbWeight::get().writes(8 as Weight))]11451146 #[weight = <T as Config>::WeightInfo::create_item(data.len())]1147 #[transactional]1148 pub fn create_item(origin, collection_id: CollectionId, owner: T::CrossAccountId, data: CreateItemData) -> DispatchResult {1149 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1150 let collection = Self::get_collection(collection_id)?;11511152 Self::create_item_internal(&sender, &collection, &owner, data)?;11531154 Self::submit_logs(collection)?;1155 Ok(())1156 }11571158 /// This method creates multiple items in a collection created with CreateCollection method.1159 /// 1160 /// # Permissions1161 /// 1162 /// * Collection Owner.1163 /// * Collection Admin.1164 /// * Anyone if1165 /// * White List is enabled, and1166 /// * Address is added to white list, and1167 /// * MintPermission is enabled (see SetMintPermission method)1168 /// 1169 /// # Arguments1170 /// 1171 /// * collection_id: ID of the collection.1172 /// 1173 /// * itemsData: Array items properties. Each property is an array of bytes itself, see [create_item].1174 /// 1175 /// * owner: Address, initial owner of the NFT.1176 #[weight = <T as Config>::WeightInfo::create_item(items_data.into_iter()1177 .map(|data| { data.len() })1178 .sum())]1179 #[transactional]1180 pub fn create_multiple_items(origin, collection_id: CollectionId, owner: T::CrossAccountId, items_data: Vec<CreateItemData>) -> DispatchResult {11811182 ensure!(items_data.len() > 0, Error::<T>::EmptyArgument);1183 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1184 let collection = Self::get_collection(collection_id)?;11851186 Self::create_multiple_items_internal(&sender, &collection, &owner, items_data)?;11871188 Self::submit_logs(collection)?;1189 Ok(())1190 }11911192 /// Destroys a concrete instance of NFT.1193 /// 1194 /// # Permissions1195 /// 1196 /// * Collection Owner.1197 /// * Collection Admin.1198 /// * Current NFT Owner.1199 /// 1200 /// # Arguments1201 /// 1202 /// * collection_id: ID of the collection.1203 /// 1204 /// * item_id: ID of NFT to burn.1205 #[weight = <T as Config>::WeightInfo::burn_item()]1206 #[transactional]1207 pub fn burn_item(origin, collection_id: CollectionId, item_id: TokenId, value: u128) -> DispatchResult {12081209 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1210 let target_collection = Self::get_collection(collection_id)?;12111212 Self::burn_item_internal(&sender, &target_collection, item_id, value)?;12131214 Self::submit_logs(target_collection)?;1215 Ok(())1216 }12171218 /// Change ownership of the token.1219 /// 1220 /// # Permissions1221 /// 1222 /// * Collection Owner1223 /// * Collection Admin1224 /// * Current NFT owner1225 ///1226 /// # Arguments1227 /// 1228 /// * recipient: Address of token recipient.1229 /// 1230 /// * collection_id.1231 /// 1232 /// * item_id: ID of the item1233 /// * Non-Fungible Mode: Required.1234 /// * Fungible Mode: Ignored.1235 /// * Re-Fungible Mode: Required.1236 /// 1237 /// * value: Amount to transfer.1238 /// * Non-Fungible Mode: Ignored1239 /// * Fungible Mode: Must specify transferred amount1240 /// * Re-Fungible Mode: Must specify transferred portion (between 0 and 1)1241 #[weight = <T as Config>::WeightInfo::transfer()]1242 #[transactional]1243 pub fn transfer(origin, recipient: T::CrossAccountId, collection_id: CollectionId, item_id: TokenId, value: u128) -> DispatchResult {1244 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1245 let collection = Self::get_collection(collection_id)?;12461247 Self::transfer_internal(&sender, &recipient, &collection, item_id, value)?;12481249 Self::submit_logs(collection)?;1250 Ok(())1251 }12521253 /// Set, change, or remove approved address to transfer the ownership of the NFT.1254 /// 1255 /// # Permissions1256 /// 1257 /// * Collection Owner1258 /// * Collection Admin1259 /// * Current NFT owner1260 /// 1261 /// # Arguments1262 /// 1263 /// * approved: Address that is approved to transfer this NFT or zero (if needed to remove approval).1264 /// 1265 /// * collection_id.1266 /// 1267 /// * item_id: ID of the item.1268 #[weight = <T as Config>::WeightInfo::approve()]1269 #[transactional]1270 pub fn approve(origin, spender: T::CrossAccountId, collection_id: CollectionId, item_id: TokenId, amount: u128) -> DispatchResult {1271 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1272 let collection = Self::get_collection(collection_id)?;12731274 Self::approve_internal(&sender, &spender, &collection, item_id, amount)?;12751276 Self::submit_logs(collection)?;1277 Ok(())1278 }1279 1280 /// 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.1281 /// 1282 /// # Permissions1283 /// * Collection Owner1284 /// * Collection Admin1285 /// * Current NFT owner1286 /// * Address approved by current NFT owner1287 /// 1288 /// # Arguments1289 /// 1290 /// * from: Address that owns token.1291 /// 1292 /// * recipient: Address of token recipient.1293 /// 1294 /// * collection_id.1295 /// 1296 /// * item_id: ID of the item.1297 /// 1298 /// * value: Amount to transfer.1299 #[weight = <T as Config>::WeightInfo::transfer_from()]1300 #[transactional]1301 pub fn transfer_from(origin, from: T::CrossAccountId, recipient: T::CrossAccountId, collection_id: CollectionId, item_id: TokenId, value: u128 ) -> DispatchResult {1302 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1303 let collection = Self::get_collection(collection_id)?;13041305 Self::transfer_from_internal(&sender, &from, &recipient, &collection, item_id, value)?;13061307 Self::submit_logs(collection)?;1308 Ok(())1309 }1310 // #[weight = 0]1311 // // let no_perm_mes = "You do not have permissions to modify this collection";1312 // // ensure!(<ApprovedList<T>>::contains_key((collection_id, item_id)), no_perm_mes);1313 // // let list_itm = <ApprovedList<T>>::get((collection_id, item_id));1314 // // ensure!(list_itm.contains(&new_owner.clone()), no_perm_mes);13151316 // // // on_nft_received call13171318 // // Self::transfer(origin, collection_id, item_id, new_owner)?;13191320 // Ok(())1321 // }13221323 /// Set off-chain data schema.1324 /// 1325 /// # Permissions1326 /// 1327 /// * Collection Owner1328 /// * Collection Admin1329 /// 1330 /// # Arguments1331 /// 1332 /// * collection_id.1333 /// 1334 /// * schema: String representing the offchain data schema.1335 #[weight = <T as Config>::WeightInfo::set_variable_meta_data()]1336 #[transactional]1337 pub fn set_variable_meta_data (1338 origin,1339 collection_id: CollectionId,1340 item_id: TokenId,1341 data: Vec<u8>1342 ) -> DispatchResult {1343 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1344 1345 let collection = Self::get_collection(collection_id)?;13461347 Self::set_variable_meta_data_internal(&sender, &collection, item_id, data)?;13481349 Ok(())1350 }1351 1352 /// Set schema standard1353 /// ImageURL1354 /// Unique1355 /// 1356 /// # Permissions1357 /// 1358 /// * Collection Owner1359 /// * Collection Admin1360 /// 1361 /// # Arguments1362 /// 1363 /// * collection_id.1364 /// 1365 /// * schema: SchemaVersion: enum1366 #[weight = <T as Config>::WeightInfo::set_schema_version()]1367 #[transactional]1368 pub fn set_schema_version(1369 origin,1370 collection_id: CollectionId,1371 version: SchemaVersion1372 ) -> DispatchResult {1373 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1374 let mut target_collection = Self::get_collection(collection_id)?;1375 Self::check_owner_or_admin_permissions(&target_collection, &sender)?;1376 target_collection.schema_version = version;1377 Self::save_collection(target_collection);13781379 Ok(())1380 }13811382 /// Set off-chain data schema.1383 /// 1384 /// # Permissions1385 /// 1386 /// * Collection Owner1387 /// * Collection Admin1388 /// 1389 /// # Arguments1390 /// 1391 /// * collection_id.1392 /// 1393 /// * schema: String representing the offchain data schema.1394 #[weight = <T as Config>::WeightInfo::set_offchain_schema()]1395 #[transactional]1396 pub fn set_offchain_schema(1397 origin,1398 collection_id: CollectionId,1399 schema: Vec<u8>1400 ) -> DispatchResult {1401 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1402 let mut target_collection = Self::get_collection(collection_id)?;1403 Self::check_owner_or_admin_permissions(&target_collection, &sender)?;14041405 // check schema limit1406 ensure!(schema.len() as u32 <= ChainLimit::get().offchain_schema_limit, "");14071408 target_collection.offchain_schema = schema;1409 Self::save_collection(target_collection);14101411 Ok(())1412 }14131414 /// Set const on-chain data schema.1415 /// 1416 /// # Permissions1417 /// 1418 /// * Collection Owner1419 /// * Collection Admin1420 /// 1421 /// # Arguments1422 /// 1423 /// * collection_id.1424 /// 1425 /// * schema: String representing the const on-chain data schema.1426 #[weight = <T as Config>::WeightInfo::set_const_on_chain_schema()]1427 #[transactional]1428 pub fn set_const_on_chain_schema (1429 origin,1430 collection_id: CollectionId,1431 schema: Vec<u8>1432 ) -> DispatchResult {1433 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1434 let mut target_collection = Self::get_collection(collection_id)?;1435 Self::check_owner_or_admin_permissions(&target_collection, &sender)?;14361437 // check schema limit1438 ensure!(schema.len() as u32 <= ChainLimit::get().const_on_chain_schema_limit, "");14391440 target_collection.const_on_chain_schema = schema;1441 Self::save_collection(target_collection);14421443 Ok(())1444 }14451446 /// Set variable on-chain data schema.1447 /// 1448 /// # Permissions1449 /// 1450 /// * Collection Owner1451 /// * Collection Admin1452 /// 1453 /// # Arguments1454 /// 1455 /// * collection_id.1456 /// 1457 /// * schema: String representing the variable on-chain data schema.1458 #[weight = <T as Config>::WeightInfo::set_const_on_chain_schema()]1459 #[transactional]1460 pub fn set_variable_on_chain_schema (1461 origin,1462 collection_id: CollectionId,1463 schema: Vec<u8>1464 ) -> DispatchResult {1465 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1466 let mut target_collection = Self::get_collection(collection_id)?;1467 Self::check_owner_or_admin_permissions(&target_collection, &sender)?;14681469 // check schema limit1470 ensure!(schema.len() as u32 <= ChainLimit::get().variable_on_chain_schema_limit, "");14711472 target_collection.variable_on_chain_schema = schema;1473 Self::save_collection(target_collection);14741475 Ok(())1476 }14771478 // Sudo permissions function1479 #[weight = <T as Config>::WeightInfo::set_chain_limits()]1480 #[transactional]1481 pub fn set_chain_limits(1482 origin,1483 limits: ChainLimits1484 ) -> DispatchResult {14851486 #[cfg(not(feature = "runtime-benchmarks"))]1487 ensure_root(origin)?;14881489 <ChainLimit>::put(limits);1490 Ok(())1491 }14921493 /// Enable smart contract self-sponsoring.1494 /// 1495 /// # Permissions1496 /// 1497 /// * Contract Owner1498 /// 1499 /// # Arguments1500 /// 1501 /// * contract address1502 /// * enable flag1503 /// 1504 #[weight = <T as Config>::WeightInfo::enable_contract_sponsoring()]1505 #[transactional]1506 pub fn enable_contract_sponsoring(1507 origin,1508 contract_address: T::AccountId,1509 enable: bool1510 ) -> DispatchResult {15111512 let sender = ensure_signed(origin)?;15131514 #[cfg(feature = "runtime-benchmarks")]1515 <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());15161517 Self::ensure_contract_owned(sender, &contract_address)?;15181519 <ContractSelfSponsoring<T>>::insert(contract_address, enable);1520 Ok(())1521 }15221523 /// Set the rate limit for contract sponsoring to specified number of blocks.1524 /// 1525 /// If not set (has the default value of 0 blocks), the sponsoring will be disabled. 1526 /// If set to the number B (for blocks), the transactions will be sponsored with a rate 1527 /// limit of B, i.e. fees for every transaction sent to this smart contract will be paid 1528 /// from contract endowment if there are at least B blocks between such transactions. 1529 /// Nonetheless, if transactions are sent more frequently, the fees are paid by the sender.1530 /// 1531 /// # Permissions1532 /// 1533 /// * Contract Owner1534 /// 1535 /// # Arguments1536 /// 1537 /// -`contract_address`: Address of the contract to sponsor1538 /// -`rate_limit`: Number of blocks to wait until the next sponsored transaction is allowed1539 /// 1540 #[weight = <T as Config>::WeightInfo::set_contract_sponsoring_rate_limit()]1541 #[transactional]1542 pub fn set_contract_sponsoring_rate_limit(1543 origin,1544 contract_address: T::AccountId,1545 rate_limit: T::BlockNumber1546 ) -> DispatchResult {1547 let sender = ensure_signed(origin)?;15481549 #[cfg(feature = "runtime-benchmarks")]1550 <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());15511552 Self::ensure_contract_owned(sender, &contract_address)?;1553 <ContractSponsoringRateLimit<T>>::insert(contract_address, rate_limit);1554 Ok(())1555 }15561557 /// Enable the white list for a contract. Only addresses added to the white list with addToContractWhiteList will be able to call this smart contract.1558 /// 1559 /// # Permissions1560 /// 1561 /// * Address that deployed smart contract.1562 /// 1563 /// # Arguments1564 /// 1565 /// -`contract_address`: Address of the contract.1566 /// 1567 /// - `enable`: . 1568 #[weight = <T as Config>::WeightInfo::toggle_contract_white_list()]1569 #[transactional]1570 pub fn toggle_contract_white_list(1571 origin,1572 contract_address: T::AccountId,1573 enable: bool1574 ) -> DispatchResult {1575 let sender = ensure_signed(origin)?;15761577 #[cfg(feature = "runtime-benchmarks")]1578 <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());15791580 Self::ensure_contract_owned(sender, &contract_address)?;1581 if enable {1582 <ContractWhiteListEnabled<T>>::insert(contract_address, true);1583 } else {1584 <ContractWhiteListEnabled<T>>::remove(contract_address);1585 }1586 Ok(())1587 }1588 1589 /// Add an address to smart contract white list.1590 /// 1591 /// # Permissions1592 /// 1593 /// * Address that deployed smart contract.1594 /// 1595 /// # Arguments1596 /// 1597 /// -`contract_address`: Address of the contract.1598 ///1599 /// -`account_address`: Address to add.1600 #[weight = <T as Config>::WeightInfo::add_to_contract_white_list()]1601 #[transactional]1602 pub fn add_to_contract_white_list(1603 origin,1604 contract_address: T::AccountId,1605 account_address: T::AccountId1606 ) -> DispatchResult {1607 let sender = ensure_signed(origin)?;16081609 #[cfg(feature = "runtime-benchmarks")]1610 <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());1611 1612 Self::ensure_contract_owned(sender, &contract_address)?; 1613 <ContractWhiteList<T>>::insert(contract_address, account_address, true);1614 Ok(())1615 }16161617 /// Remove an address from smart contract white list.1618 /// 1619 /// # Permissions1620 /// 1621 /// * Address that deployed smart contract.1622 /// 1623 /// # Arguments1624 /// 1625 /// -`contract_address`: Address of the contract.1626 ///1627 /// -`account_address`: Address to remove.1628 #[weight = <T as Config>::WeightInfo::remove_from_contract_white_list()]1629 #[transactional]1630 pub fn remove_from_contract_white_list(1631 origin,1632 contract_address: T::AccountId,1633 account_address: T::AccountId1634 ) -> DispatchResult {1635 let sender = ensure_signed(origin)?;16361637 #[cfg(feature = "runtime-benchmarks")]1638 <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());16391640 Self::ensure_contract_owned(sender, &contract_address)?;1641 <ContractWhiteList<T>>::remove(contract_address, account_address);1642 Ok(())1643 }16441645 #[weight = <T as Config>::WeightInfo::set_collection_limits()]1646 #[transactional]1647 pub fn set_collection_limits(1648 origin,1649 collection_id: u32,1650 new_limits: CollectionLimits<T::BlockNumber>,1651 ) -> DispatchResult {1652 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1653 let mut target_collection = Self::get_collection(collection_id)?;1654 Self::check_owner_permissions(&target_collection, &sender.as_sub())?;1655 let old_limits = &target_collection.limits;1656 let chain_limits = ChainLimit::get();16571658 // collection bounds1659 ensure!(new_limits.sponsor_transfer_timeout <= MAX_SPONSOR_TIMEOUT &&1660 new_limits.account_token_ownership_limit <= MAX_TOKEN_OWNERSHIP && 1661 new_limits.sponsored_data_size <= chain_limits.custom_data_limit,1662 Error::<T>::CollectionLimitBoundsExceeded);16631664 // token_limit check prev1665 ensure!(old_limits.token_limit >= new_limits.token_limit, Error::<T>::CollectionTokenLimitExceeded);1666 ensure!(new_limits.token_limit > 0, Error::<T>::CollectionTokenLimitExceeded);16671668 ensure!(1669 (old_limits.owner_can_transfer || !new_limits.owner_can_transfer) &&1670 (old_limits.owner_can_destroy || !new_limits.owner_can_destroy),1671 Error::<T>::OwnerPermissionsCantBeReverted,1672 );16731674 target_collection.limits = new_limits;1675 Self::save_collection(target_collection);16761677 Ok(())1678 } 1679 }1680}16811682impl<T: Config> Module<T> {1683 pub fn create_item_internal(sender: &T::CrossAccountId, collection: &CollectionHandle<T>, owner: &T::CrossAccountId, data: CreateItemData) -> DispatchResult {1684 Self::can_create_items_in_collection(&collection, &sender, &owner, 1)?;1685 Self::validate_create_item_args(&collection, &data)?;1686 Self::create_item_no_validation(&collection, owner, data)?;16871688 Ok(())1689 }16901691 pub fn transfer_internal(sender: &T::CrossAccountId, recipient: &T::CrossAccountId, target_collection: &CollectionHandle<T>, item_id: TokenId, value: u128) -> DispatchResult {1692 // Limits check1693 Self::is_correct_transfer(target_collection, &recipient)?;16941695 // Transfer permissions check1696 ensure!(Self::is_item_owner(&sender, target_collection, item_id) ||1697 Self::is_owner_or_admin_permissions(target_collection, &sender),1698 Error::<T>::NoPermission);16991700 if target_collection.access == AccessMode::WhiteList {1701 Self::check_white_list(target_collection, &sender)?;1702 Self::check_white_list(target_collection, &recipient)?;1703 }17041705 match target_collection.mode1706 {1707 CollectionMode::NFT => Self::transfer_nft(target_collection, item_id, sender.clone(), recipient.clone())?,1708 CollectionMode::Fungible(_) => Self::transfer_fungible(target_collection, value, &sender, &recipient)?,1709 CollectionMode::ReFungible => Self::transfer_refungible(target_collection, item_id, value, sender.clone(), recipient.clone())?,1710 _ => ()1711 };17121713 Self::deposit_event(RawEvent::Transfer(target_collection.id, item_id, sender.clone(), recipient.clone(), value));17141715 Ok(())1716 }17171718 pub fn approve_internal(1719 sender: &T::CrossAccountId,1720 spender: &T::CrossAccountId,1721 collection: &CollectionHandle<T>,1722 item_id: TokenId,1723 amount: u1281724 ) -> DispatchResult {1725 Self::token_exists(&collection, item_id)?;17261727 // Transfer permissions check1728 let bypasses_limits = collection.limits.owner_can_transfer &&1729 Self::is_owner_or_admin_permissions(1730 &collection,1731 &sender,1732 );17331734 let allowance_limit = if bypasses_limits {1735 None1736 } else if let Some(amount) = Self::owned_amount(1737 &sender,1738 &collection,1739 item_id,1740 ) {1741 Some(amount)1742 } else {1743 fail!(Error::<T>::NoPermission);1744 };17451746 if collection.access == AccessMode::WhiteList {1747 Self::check_white_list(&collection, &sender)?;1748 Self::check_white_list(&collection, &spender)?;1749 }17501751 let allowance: u128 = amount1752 .checked_add(<Allowances<T>>::get(collection.id, (item_id, sender.as_sub(), spender.as_sub())))1753 .ok_or(Error::<T>::NumOverflow)?;1754 if let Some(limit) = allowance_limit {1755 ensure!(limit >= allowance, Error::<T>::TokenValueTooLow);1756 }1757 <Allowances<T>>::insert(collection.id, (item_id, sender.as_sub(), spender.as_sub()), allowance);17581759 if matches!(collection.mode, CollectionMode::NFT) {1760 // TODO: NFT: only one owner may exist for token in ERC7211761 collection.log(1762 Vec::from([1763 eth::APPROVAL_NFT_TOPIC,1764 eth::address_to_topic(sender.as_eth()),1765 eth::address_to_topic(spender.as_eth()),1766 eth::u32_to_topic(item_id),1767 ]),1768 abi_encode!(),1769 );1770 }17711772 if matches!(collection.mode, CollectionMode::Fungible(_)) {1773 // TODO: NFT: only one owner may exist for token in ERC201774 collection.log(1775 Vec::from([1776 eth::APPROVAL_FUNGIBLE_TOPIC,1777 eth::address_to_topic(sender.as_eth()),1778 eth::address_to_topic(spender.as_eth()),1779 ]),1780 abi_encode!(uint256(allowance.into())),1781 );1782 }17831784 Self::deposit_event(RawEvent::Approved(collection.id, item_id, sender.clone(), spender.clone(), allowance));1785 Ok(())1786 }17871788 pub fn transfer_from_internal(1789 sender: &T::CrossAccountId,1790 from: &T::CrossAccountId,1791 recipient: &T::CrossAccountId,1792 collection: &CollectionHandle<T>,1793 item_id: TokenId,1794 amount: u128,1795 ) -> DispatchResult {1796 // Check approval1797 let approval: u128 = <Allowances<T>>::get(collection.id, (item_id, from.as_sub(), sender.as_sub()));17981799 // Limits check1800 Self::is_correct_transfer(&collection, &recipient)?;18011802 // Transfer permissions check1803 ensure!(1804 approval >= amount || 1805 (1806 collection.limits.owner_can_transfer &&1807 Self::is_owner_or_admin_permissions(&collection, &sender)1808 ),1809 Error::<T>::NoPermission1810 );18111812 if collection.access == AccessMode::WhiteList {1813 Self::check_white_list(&collection, &sender)?;1814 Self::check_white_list(&collection, &recipient)?;1815 }18161817 // Reduce approval by transferred amount or remove if remaining approval drops to 01818 let allowance = approval.saturating_sub(amount);1819 if allowance > 0 {1820 <Allowances<T>>::insert(collection.id, (item_id, from.as_sub(), sender.as_sub()), allowance);1821 } else {1822 <Allowances<T>>::remove(collection.id, (item_id, from.as_sub(), sender.as_sub()));1823 }18241825 match collection.mode {1826 CollectionMode::NFT => {1827 Self::transfer_nft(&collection, item_id, from.clone(), recipient.clone())?1828 }1829 CollectionMode::Fungible(_) => {1830 Self::transfer_fungible(&collection, amount, &from, &recipient)?1831 }1832 CollectionMode::ReFungible => {1833 Self::transfer_refungible(&collection, item_id, amount, from.clone(), recipient.clone())?1834 }1835 _ => ()1836 };18371838 if matches!(collection.mode, CollectionMode::Fungible(_)) {1839 collection.log(1840 Vec::from([1841 eth::APPROVAL_FUNGIBLE_TOPIC,1842 eth::address_to_topic(from.as_eth()),1843 eth::address_to_topic(sender.as_eth()),1844 ]),1845 abi_encode!(uint256(allowance.into())),1846 );1847 }18481849 Ok(())1850 }18511852 pub fn set_variable_meta_data_internal(1853 sender: &T::CrossAccountId,1854 collection: &CollectionHandle<T>, 1855 item_id: TokenId,1856 data: Vec<u8>,1857 ) -> DispatchResult {1858 Self::token_exists(&collection, item_id)?;18591860 ensure!(ChainLimit::get().custom_data_limit >= data.len() as u32, Error::<T>::TokenVariableDataLimitExceeded);18611862 // Modify permissions check1863 ensure!(Self::is_item_owner(&sender, &collection, item_id) ||1864 Self::is_owner_or_admin_permissions(&collection, &sender),1865 Error::<T>::NoPermission);18661867 match collection.mode1868 {1869 CollectionMode::NFT => Self::set_nft_variable_data(&collection, item_id, data)?,1870 CollectionMode::ReFungible => Self::set_re_fungible_variable_data(&collection, item_id, data)?,1871 CollectionMode::Fungible(_) => fail!(Error::<T>::CantStoreMetadataInFungibleTokens),1872 _ => fail!(Error::<T>::UnexpectedCollectionType)1873 };18741875 Ok(())1876 }18771878 pub fn create_multiple_items_internal(1879 sender: &T::CrossAccountId,1880 collection: &CollectionHandle<T>,1881 owner: &T::CrossAccountId,1882 items_data: Vec<CreateItemData>,1883 ) -> DispatchResult {1884 Self::can_create_items_in_collection(&collection, &sender, &owner, items_data.len() as u32)?;18851886 for data in &items_data {1887 Self::validate_create_item_args(&collection, data)?;1888 }1889 for data in &items_data {1890 Self::create_item_no_validation(&collection, owner, data.clone())?;1891 }18921893 Ok(())1894 }18951896 pub fn burn_item_internal(1897 sender: &T::CrossAccountId,1898 collection: &CollectionHandle<T>,1899 item_id: TokenId,1900 value: u128,1901 ) -> DispatchResult {1902 ensure!(1903 Self::is_item_owner(&sender, &collection, item_id) ||1904 (1905 collection.limits.owner_can_transfer &&1906 Self::is_owner_or_admin_permissions(&collection, &sender)1907 ),1908 Error::<T>::NoPermission1909 );19101911 if collection.access == AccessMode::WhiteList {1912 Self::check_white_list(&collection, &sender)?;1913 }19141915 match collection.mode1916 {1917 CollectionMode::NFT => Self::burn_nft_item(&collection, item_id)?,1918 CollectionMode::Fungible(_) => Self::burn_fungible_item(&sender, &collection, value)?,1919 CollectionMode::ReFungible => Self::burn_refungible_item(&collection, item_id, &sender)?,1920 _ => ()1921 };19221923 Ok(())1924 }19251926 pub fn toggle_white_list_internal(1927 sender: &T::CrossAccountId,1928 collection: &CollectionHandle<T>,1929 address: &T::CrossAccountId,1930 whitelisted: bool,1931 ) -> DispatchResult {1932 Self::check_owner_or_admin_permissions(&collection, &sender)?;19331934 if whitelisted {1935 <WhiteList<T>>::insert(collection.id, address.as_sub(), true);1936 } else {1937 <WhiteList<T>>::remove(collection.id, address.as_sub());1938 }19391940 Ok(())1941 }19421943 fn is_correct_transfer(collection: &CollectionHandle<T>, recipient: &T::CrossAccountId) -> DispatchResult {1944 let collection_id = collection.id;19451946 // check token limit and account token limit1947 let account_items: u32 = <AddressTokens<T>>::get(collection_id, recipient.as_sub()).len() as u32;1948 ensure!(collection.limits.account_token_ownership_limit > account_items, Error::<T>::AccountTokenLimitExceeded);1949 1950 Ok(())1951 }19521953 fn can_create_items_in_collection(collection: &CollectionHandle<T>, sender: &T::CrossAccountId, owner: &T::CrossAccountId, amount: u32) -> DispatchResult {1954 let collection_id = collection.id;19551956 // check token limit and account token limit1957 let total_items: u32 = ItemListIndex::get(collection_id)1958 .checked_add(amount)1959 .ok_or(Error::<T>::CollectionTokenLimitExceeded)?;1960 let account_items: u32 = (<AddressTokens<T>>::get(collection_id, owner.as_sub()).len() as u32)1961 .checked_add(amount)1962 .ok_or(Error::<T>::AccountTokenLimitExceeded)?;1963 ensure!(collection.limits.token_limit >= total_items, Error::<T>::CollectionTokenLimitExceeded);1964 ensure!(collection.limits.account_token_ownership_limit >= account_items, Error::<T>::AccountTokenLimitExceeded);19651966 if !Self::is_owner_or_admin_permissions(collection, &sender) {1967 ensure!(collection.mint_mode == true, Error::<T>::PublicMintingNotAllowed);1968 Self::check_white_list(collection, owner)?;1969 Self::check_white_list(collection, sender)?;1970 }19711972 Ok(())1973 }19741975 fn validate_create_item_args(target_collection: &CollectionHandle<T>, data: &CreateItemData) -> DispatchResult {1976 match target_collection.mode1977 {1978 CollectionMode::NFT => {1979 if let CreateItemData::NFT(data) = data {1980 // check sizes1981 ensure!(ChainLimit::get().custom_data_limit >= data.const_data.len() as u32, Error::<T>::TokenConstDataLimitExceeded);1982 ensure!(ChainLimit::get().custom_data_limit >= data.variable_data.len() as u32, Error::<T>::TokenVariableDataLimitExceeded);1983 } else {1984 fail!(Error::<T>::NotNftDataUsedToMintNftCollectionToken);1985 }1986 },1987 CollectionMode::Fungible(_) => {1988 if let CreateItemData::Fungible(_) = data {1989 } else {1990 fail!(Error::<T>::NotFungibleDataUsedToMintFungibleCollectionToken);1991 }1992 },1993 CollectionMode::ReFungible => {1994 if let CreateItemData::ReFungible(data) = data {19951996 // check sizes1997 ensure!(ChainLimit::get().custom_data_limit >= data.const_data.len() as u32, Error::<T>::TokenConstDataLimitExceeded);1998 ensure!(ChainLimit::get().custom_data_limit >= data.variable_data.len() as u32, Error::<T>::TokenVariableDataLimitExceeded);19992000 // Check refungibility limits2001 ensure!(data.pieces <= MAX_REFUNGIBLE_PIECES, Error::<T>::WrongRefungiblePieces);2002 ensure!(data.pieces > 0, Error::<T>::WrongRefungiblePieces);2003 } else {2004 fail!(Error::<T>::NotReFungibleDataUsedToMintReFungibleCollectionToken);2005 }2006 },2007 _ => { fail!(Error::<T>::UnexpectedCollectionType); }2008 };20092010 Ok(())2011 }20122013 fn create_item_no_validation(collection: &CollectionHandle<T>, owner: &T::CrossAccountId, data: CreateItemData) -> DispatchResult {2014 match data2015 {2016 CreateItemData::NFT(data) => {2017 let item = NftItemType {2018 owner: owner.clone(),2019 const_data: data.const_data,2020 variable_data: data.variable_data2021 };20222023 Self::add_nft_item(collection, item)?;2024 },2025 CreateItemData::Fungible(data) => {2026 Self::add_fungible_item(collection, &owner, data.value)?;2027 },2028 CreateItemData::ReFungible(data) => {2029 let mut owner_list = Vec::new();2030 owner_list.push(Ownership {owner: owner.clone(), fraction: data.pieces});20312032 let item = ReFungibleItemType {2033 owner: owner_list,2034 const_data: data.const_data,2035 variable_data: data.variable_data2036 };20372038 Self::add_refungible_item(collection, item)?;2039 }2040 };20412042 Ok(())2043 }20442045 fn add_fungible_item(collection: &CollectionHandle<T>, owner: &T::CrossAccountId, value: u128) -> DispatchResult {2046 let collection_id = collection.id;20472048 // Does new owner already have an account?2049 let balance: u128 = <FungibleItemList<T>>::get(collection_id, owner.as_sub()).value;20502051 // Mint 2052 let item = FungibleItemType {2053 value: balance.checked_add(value).ok_or(Error::<T>::NumOverflow)?,2054 };2055 <FungibleItemList<T>>::insert(collection_id, owner.as_sub(), item);20562057 // Update balance2058 let new_balance = <Balance<T>>::get(collection_id, owner.as_sub())2059 .checked_add(value)2060 .ok_or(Error::<T>::NumOverflow)?;2061 <Balance<T>>::insert(collection_id, owner.as_sub(), new_balance);20622063 Self::deposit_event(RawEvent::ItemCreated(collection_id, 0, owner.clone()));2064 Ok(())2065 }20662067 fn add_refungible_item(collection: &CollectionHandle<T>, item: ReFungibleItemType<T::CrossAccountId>) -> DispatchResult {2068 let collection_id = collection.id;20692070 let current_index = <ItemListIndex>::get(collection_id)2071 .checked_add(1)2072 .ok_or(Error::<T>::NumOverflow)?;2073 let itemcopy = item.clone();20742075 ensure!(2076 item.owner.len() == 1,2077 Error::<T>::BadCreateRefungibleCall,2078 );2079 let item_owner = item.owner.first().expect("only one owner is defined");20802081 let value = item_owner.fraction;2082 let owner = item_owner.owner.clone();20832084 Self::add_token_index(collection_id, current_index, &owner)?;20852086 <ItemListIndex>::insert(collection_id, current_index);2087 <ReFungibleItemList<T>>::insert(collection_id, current_index, itemcopy);20882089 // Update balance2090 let new_balance = <Balance<T>>::get(collection_id, owner.as_sub())2091 .checked_add(value)2092 .ok_or(Error::<T>::NumOverflow)?;2093 <Balance<T>>::insert(collection_id, owner.as_sub(), new_balance);20942095 Self::deposit_event(RawEvent::ItemCreated(collection_id, current_index, owner));2096 Ok(())2097 }20982099 fn add_nft_item(collection: &CollectionHandle<T>, item: NftItemType<T::CrossAccountId>) -> DispatchResult {2100 let collection_id = collection.id;21012102 let current_index = <ItemListIndex>::get(collection_id)2103 .checked_add(1)2104 .ok_or(Error::<T>::NumOverflow)?;21052106 let item_owner = item.owner.clone();2107 Self::add_token_index(collection_id, current_index, &item.owner)?;21082109 <ItemListIndex>::insert(collection_id, current_index);2110 <NftItemList<T>>::insert(collection_id, current_index, item);21112112 // Update balance2113 let new_balance = <Balance<T>>::get(collection_id, item_owner.as_sub())2114 .checked_add(1)2115 .ok_or(Error::<T>::NumOverflow)?;2116 <Balance<T>>::insert(collection_id, item_owner.as_sub(), new_balance);21172118 collection.log(2119 Vec::from([2120 eth::TRANSFER_NFT_TOPIC,2121 eth::address_to_topic(&H160::default()),2122 eth::address_to_topic(item_owner.as_eth()),2123 eth::u32_to_topic(current_index),2124 ]),2125 abi_encode!(),2126 );2127 Self::deposit_event(RawEvent::ItemCreated(collection_id, current_index, item_owner));2128 Ok(())2129 }21302131 fn burn_refungible_item(2132 collection: &CollectionHandle<T>,2133 item_id: TokenId,2134 owner: &T::CrossAccountId,2135 ) -> DispatchResult {2136 let collection_id = collection.id;21372138 let mut token = <ReFungibleItemList<T>>::get(collection_id, item_id)2139 .ok_or(Error::<T>::TokenNotFound)?;2140 let rft_balance = token2141 .owner2142 .iter()2143 .find(|&i| i.owner == *owner)2144 .ok_or(Error::<T>::TokenNotFound)?;2145 Self::remove_token_index(collection_id, item_id, owner)?;21462147 // update balance2148 let new_balance = <Balance<T>>::get(collection_id, rft_balance.owner.as_sub())2149 .checked_sub(rft_balance.fraction)2150 .ok_or(Error::<T>::NumOverflow)?;2151 <Balance<T>>::insert(collection_id, rft_balance.owner.as_sub(), new_balance);21522153 // Re-create owners list with sender removed2154 let index = token2155 .owner2156 .iter()2157 .position(|i| i.owner == *owner)2158 .expect("owned item is exists");2159 token.owner.remove(index);2160 let owner_count = token.owner.len();21612162 // Burn the token completely if this was the last (only) owner2163 if owner_count == 0 {2164 <ReFungibleItemList<T>>::remove(collection_id, item_id);2165 <VariableMetaDataBasket<T>>::remove(collection_id, item_id);2166 }2167 else {2168 <ReFungibleItemList<T>>::insert(collection_id, item_id, token);2169 }21702171 Ok(())2172 }21732174 fn burn_nft_item(collection: &CollectionHandle<T>, item_id: TokenId) -> DispatchResult {2175 let collection_id = collection.id;21762177 let item = <NftItemList<T>>::get(collection_id, item_id)2178 .ok_or(Error::<T>::TokenNotFound)?;2179 Self::remove_token_index(collection_id, item_id, &item.owner)?;21802181 // update balance2182 let new_balance = <Balance<T>>::get(collection_id, item.owner.as_sub())2183 .checked_sub(1)2184 .ok_or(Error::<T>::NumOverflow)?;2185 <Balance<T>>::insert(collection_id, item.owner.as_sub(), new_balance);2186 <NftItemList<T>>::remove(collection_id, item_id);2187 <VariableMetaDataBasket<T>>::remove(collection_id, item_id);21882189 Self::deposit_event(RawEvent::ItemDestroyed(collection.id, item_id));2190 Ok(())2191 }21922193 fn burn_fungible_item(owner: &T::CrossAccountId, collection: &CollectionHandle<T>, value: u128) -> DispatchResult {2194 let collection_id = collection.id;21952196 let mut balance = <FungibleItemList<T>>::get(collection_id, owner.as_sub());2197 ensure!(balance.value >= value, Error::<T>::TokenValueNotEnough);21982199 // update balance2200 let new_balance = <Balance<T>>::get(collection_id, owner.as_sub())2201 .checked_sub(value)2202 .ok_or(Error::<T>::NumOverflow)?;2203 <Balance<T>>::insert(collection_id, owner.as_sub(), new_balance);22042205 if balance.value - value > 0 {2206 balance.value -= value;2207 <FungibleItemList<T>>::insert(collection_id, owner.as_sub(), balance);2208 }2209 else {2210 <FungibleItemList<T>>::remove(collection_id, owner.as_sub());2211 }22122213 collection.log(2214 Vec::from([2215 eth::TRANSFER_FUNGIBLE_TOPIC,2216 eth::address_to_topic(owner.as_eth()),2217 eth::address_to_topic(&H160::default()),2218 ]),2219 abi_encode!(uint256(value.into())),2220 );2221 Ok(())2222 }22232224 pub fn get_collection(collection_id: CollectionId) -> Result<CollectionHandle<T>, sp_runtime::DispatchError> {2225 Ok(<CollectionHandle<T>>::get(collection_id)2226 .ok_or(Error::<T>::CollectionNotFound)?)2227 }22282229 fn save_collection(collection: CollectionHandle<T>) {2230 <CollectionById<T>>::insert(collection.id, collection.into_inner());2231 }22322233 pub fn submit_logs(collection: CollectionHandle<T>) -> DispatchResult {2234 if collection.logs.is_empty() {2235 return Ok(())2236 }2237 T::EthereumTransactionSender::submit_logs_transaction(2238 eth::generate_transaction(collection.id, T::EthereumChainId::get()),2239 collection.logs.retrieve_logs_for_contract(eth::collection_id_to_address(collection.id)),2240 )2241 }22422243 fn check_owner_permissions(target_collection: &CollectionHandle<T>, subject: &T::AccountId) -> DispatchResult {2244 ensure!(2245 *subject == target_collection.owner,2246 Error::<T>::NoPermission2247 );22482249 Ok(())2250 }22512252 fn is_owner_or_admin_permissions(collection: &CollectionHandle<T>, subject: &T::CrossAccountId) -> bool {2253 *subject.as_sub() == collection.owner || <AdminList<T>>::get(collection.id).contains(&subject)2254 }22552256 fn check_owner_or_admin_permissions(2257 collection: &CollectionHandle<T>,2258 subject: &T::CrossAccountId,2259 ) -> DispatchResult {2260 ensure!(Self::is_owner_or_admin_permissions(collection, subject), Error::<T>::NoPermission);22612262 Ok(())2263 }22642265 fn owned_amount(2266 subject: &T::CrossAccountId,2267 target_collection: &CollectionHandle<T>,2268 item_id: TokenId,2269 ) -> Option<u128> {2270 let collection_id = target_collection.id;22712272 match target_collection.mode {2273 CollectionMode::NFT => (<NftItemList<T>>::get(collection_id, item_id)?.owner == *subject)2274 .then(|| 1),2275 CollectionMode::Fungible(_) => Some(<FungibleItemList<T>>::get(collection_id, &subject.as_sub())2276 .value),2277 CollectionMode::ReFungible => <ReFungibleItemList<T>>::get(collection_id, item_id)?2278 .owner2279 .iter()2280 .find(|i| i.owner == *subject)2281 .map(|i| i.fraction),2282 CollectionMode::Invalid => None,2283 }2284 }22852286 fn is_item_owner(subject: &T::CrossAccountId, target_collection: &CollectionHandle<T>, item_id: TokenId) -> bool {2287 match target_collection.mode {2288 CollectionMode::Fungible(_) => true,2289 _ => Self::owned_amount(&subject, target_collection, item_id).is_some(),2290 }2291 }22922293 fn check_white_list(collection: &CollectionHandle<T>, address: &T::CrossAccountId) -> DispatchResult {2294 let collection_id = collection.id;22952296 let mes = Error::<T>::AddresNotInWhiteList;2297 ensure!(<WhiteList<T>>::contains_key(collection_id, address.as_sub()), mes);22982299 Ok(())2300 }23012302 /// Check if token exists. In case of Fungible, check if there is an entry for 2303 /// the owner in fungible balances double map2304 fn token_exists(2305 target_collection: &CollectionHandle<T>,2306 item_id: TokenId,2307 ) -> DispatchResult {2308 let collection_id = target_collection.id;2309 let exists = match target_collection.mode2310 {2311 CollectionMode::NFT => <NftItemList<T>>::contains_key(collection_id, item_id),2312 CollectionMode::Fungible(_) => true,2313 CollectionMode::ReFungible => <ReFungibleItemList<T>>::contains_key(collection_id, item_id),2314 _ => false2315 };23162317 ensure!(exists == true, Error::<T>::TokenNotFound);2318 Ok(())2319 }23202321 fn transfer_fungible(2322 collection: &CollectionHandle<T>,2323 value: u128,2324 owner: &T::CrossAccountId,2325 recipient: &T::CrossAccountId,2326 ) -> DispatchResult {2327 let collection_id = collection.id;23282329 let mut balance = <FungibleItemList<T>>::get(collection_id, owner.as_sub());2330 ensure!(balance.value >= value, Error::<T>::TokenValueTooLow);23312332 // Send balance to recipient (updates balanceOf of recipient)2333 Self::add_fungible_item(collection, recipient, value)?;23342335 // update balanceOf of sender2336 <Balance<T>>::insert(collection_id, owner.as_sub(), balance.value - value);23372338 // Reduce or remove sender2339 if balance.value == value {2340 <FungibleItemList<T>>::remove(collection_id, owner.as_sub());2341 }2342 else {2343 balance.value -= value;2344 <FungibleItemList<T>>::insert(collection_id, owner.as_sub(), balance);2345 }23462347 collection.log(2348 Vec::from([2349 eth::TRANSFER_FUNGIBLE_TOPIC,2350 eth::address_to_topic(owner.as_eth()),2351 eth::address_to_topic(recipient.as_eth()),2352 ]),2353 abi_encode!(uint256(value.into())),2354 );2355 Self::deposit_event(RawEvent::Transfer(collection.id, 1, owner.clone(), recipient.clone(), value));23562357 Ok(())2358 }23592360 fn transfer_refungible(2361 collection: &CollectionHandle<T>,2362 item_id: TokenId,2363 value: u128,2364 owner: T::CrossAccountId,2365 new_owner: T::CrossAccountId,2366 ) -> DispatchResult {2367 let collection_id = collection.id;2368 let full_item = <ReFungibleItemList<T>>::get(collection_id, item_id)2369 .ok_or(Error::<T>::TokenNotFound)?;23702371 let item = full_item2372 .owner2373 .iter()2374 .filter(|i| i.owner == owner)2375 .next()2376 .ok_or(Error::<T>::TokenNotFound)?;2377 let amount = item.fraction;23782379 ensure!(amount >= value, Error::<T>::TokenValueTooLow);23802381 // update balance2382 let balance_old_owner = <Balance<T>>::get(collection_id, item.owner.as_sub())2383 .checked_sub(value)2384 .ok_or(Error::<T>::NumOverflow)?;2385 <Balance<T>>::insert(collection_id, item.owner.as_sub(), balance_old_owner);23862387 let balance_new_owner = <Balance<T>>::get(collection_id, new_owner.as_sub())2388 .checked_add(value)2389 .ok_or(Error::<T>::NumOverflow)?;2390 <Balance<T>>::insert(collection_id, new_owner.as_sub(), balance_new_owner);23912392 let old_owner = item.owner.clone();2393 let new_owner_has_account = full_item.owner.iter().any(|i| i.owner == new_owner);23942395 // transfer2396 if amount == value && !new_owner_has_account {2397 // change owner2398 // new owner do not have account2399 let mut new_full_item = full_item.clone();2400 new_full_item2401 .owner2402 .iter_mut()2403 .find(|i| i.owner == owner)2404 .expect("old owner does present in refungible")2405 .owner = new_owner.clone();2406 <ReFungibleItemList<T>>::insert(collection_id, item_id, new_full_item);24072408 // update index collection2409 Self::move_token_index(collection_id, item_id, &old_owner, &new_owner)?;2410 } else {2411 let mut new_full_item = full_item.clone();2412 new_full_item2413 .owner2414 .iter_mut()2415 .find(|i| i.owner == owner)2416 .expect("old owner does present in refungible")2417 .fraction -= value;24182419 // separate amount2420 if new_owner_has_account {2421 // new owner has account2422 new_full_item2423 .owner2424 .iter_mut()2425 .find(|i| i.owner == new_owner)2426 .expect("new owner has account")2427 .fraction += value;2428 } else {2429 // new owner do not have account2430 new_full_item.owner.push(Ownership {2431 owner: new_owner.clone(),2432 fraction: value,2433 });2434 Self::add_token_index(collection_id, item_id, &new_owner)?;2435 }24362437 <ReFungibleItemList<T>>::insert(collection_id, item_id, new_full_item);2438 }24392440 Self::deposit_event(RawEvent::Transfer(collection.id, item_id, owner, new_owner, amount));24412442 Ok(())2443 }24442445 fn transfer_nft(2446 collection: &CollectionHandle<T>,2447 item_id: TokenId,2448 sender: T::CrossAccountId,2449 new_owner: T::CrossAccountId,2450 ) -> DispatchResult {2451 let collection_id = collection.id;2452 let mut item = <NftItemList<T>>::get(collection_id, item_id)2453 .ok_or(Error::<T>::TokenNotFound)?;24542455 ensure!(2456 sender == item.owner,2457 Error::<T>::MustBeTokenOwner2458 );24592460 // update balance2461 let balance_old_owner = <Balance<T>>::get(collection_id, item.owner.as_sub())2462 .checked_sub(1)2463 .ok_or(Error::<T>::NumOverflow)?;2464 <Balance<T>>::insert(collection_id, item.owner.as_sub(), balance_old_owner);24652466 let balance_new_owner = <Balance<T>>::get(collection_id, new_owner.as_sub())2467 .checked_add(1)2468 .ok_or(Error::<T>::NumOverflow)?;2469 <Balance<T>>::insert(collection_id, new_owner.as_sub(), balance_new_owner);24702471 // change owner2472 let old_owner = item.owner.clone();2473 item.owner = new_owner.clone();2474 <NftItemList<T>>::insert(collection_id, item_id, item);24752476 // update index collection2477 Self::move_token_index(collection_id, item_id, &old_owner, &new_owner)?;24782479 collection.log(2480 Vec::from([2481 eth::TRANSFER_NFT_TOPIC,2482 eth::address_to_topic(sender.as_eth()),2483 eth::address_to_topic(new_owner.as_eth()),2484 eth::u32_to_topic(item_id),2485 ]),2486 abi_encode!(),2487 );2488 Self::deposit_event(RawEvent::Transfer(collection.id, item_id, sender, new_owner, 1));24892490 Ok(())2491 }2492 2493 fn set_re_fungible_variable_data(2494 collection: &CollectionHandle<T>,2495 item_id: TokenId,2496 data: Vec<u8>2497 ) -> DispatchResult {2498 let collection_id = collection.id;2499 let mut item = <ReFungibleItemList<T>>::get(collection_id, item_id)2500 .ok_or(Error::<T>::TokenNotFound)?;25012502 item.variable_data = data;25032504 <ReFungibleItemList<T>>::insert(collection_id, item_id, item);25052506 Ok(())2507 }25082509 fn set_nft_variable_data(2510 collection: &CollectionHandle<T>,2511 item_id: TokenId,2512 data: Vec<u8>2513 ) -> DispatchResult {2514 let collection_id = collection.id;2515 let mut item = <NftItemList<T>>::get(collection_id, item_id)2516 .ok_or(Error::<T>::TokenNotFound)?;2517 2518 item.variable_data = data;25192520 <NftItemList<T>>::insert(collection_id, item_id, item);2521 2522 Ok(())2523 }25242525 fn init_collection(item: &Collection<T>) {2526 // check params2527 assert!(2528 item.decimal_points <= MAX_DECIMAL_POINTS,2529 "decimal_points parameter must be lower than MAX_DECIMAL_POINTS"2530 );2531 assert!(2532 item.name.len() <= 64,2533 "Collection name can not be longer than 63 char"2534 );2535 assert!(2536 item.name.len() <= 256,2537 "Collection description can not be longer than 255 char"2538 );2539 assert!(2540 item.token_prefix.len() <= 16,2541 "Token prefix can not be longer than 15 char"2542 );25432544 // Generate next collection ID2545 let next_id = CreatedCollectionCount::get()2546 .checked_add(1)2547 .unwrap();25482549 CreatedCollectionCount::put(next_id);2550 }25512552 fn init_nft_token(collection_id: CollectionId, item: &NftItemType<T::CrossAccountId>) {2553 let current_index = <ItemListIndex>::get(collection_id)2554 .checked_add(1)2555 .unwrap();25562557 Self::add_token_index(collection_id, current_index, &item.owner).unwrap();25582559 <ItemListIndex>::insert(collection_id, current_index);25602561 // Update balance2562 let new_balance = <Balance<T>>::get(collection_id, item.owner.as_sub())2563 .checked_add(1)2564 .unwrap();2565 <Balance<T>>::insert(collection_id, item.owner.as_sub(), new_balance);2566 }25672568 fn init_fungible_token(collection_id: CollectionId, owner: &T::CrossAccountId, item: &FungibleItemType) {2569 let current_index = <ItemListIndex>::get(collection_id)2570 .checked_add(1)2571 .unwrap();25722573 Self::add_token_index(collection_id, current_index, owner).unwrap();25742575 <ItemListIndex>::insert(collection_id, current_index);25762577 // Update balance2578 let new_balance = <Balance<T>>::get(collection_id, owner.as_sub())2579 .checked_add(item.value)2580 .unwrap();2581 <Balance<T>>::insert(collection_id, owner.as_sub(), new_balance);2582 }25832584 fn init_refungible_token(collection_id: CollectionId, item: &ReFungibleItemType<T::CrossAccountId>) {2585 let current_index = <ItemListIndex>::get(collection_id)2586 .checked_add(1)2587 .unwrap();25882589 let value = item.owner.first().unwrap().fraction;2590 let owner = item.owner.first().unwrap().owner.clone();25912592 Self::add_token_index(collection_id, current_index, &owner).unwrap();25932594 <ItemListIndex>::insert(collection_id, current_index);25952596 // Update balance2597 let new_balance = <Balance<T>>::get(collection_id, &owner.as_sub())2598 .checked_add(value)2599 .unwrap();2600 <Balance<T>>::insert(collection_id, owner.as_sub(), new_balance);2601 }26022603 fn add_token_index(collection_id: CollectionId, item_index: TokenId, owner: &T::CrossAccountId) -> DispatchResult {2604 // add to account limit2605 if <AccountItemCount<T>>::contains_key(owner.as_sub()) {26062607 // bound Owned tokens by a single address2608 let count = <AccountItemCount<T>>::get(owner.as_sub());2609 ensure!(count < ChainLimit::get().account_token_ownership_limit, Error::<T>::AddressOwnershipLimitExceeded);26102611 <AccountItemCount<T>>::insert(owner.as_sub(), count2612 .checked_add(1)2613 .ok_or(Error::<T>::NumOverflow)?);2614 }2615 else {2616 <AccountItemCount<T>>::insert(owner.as_sub(), 1);2617 }26182619 let list_exists = <AddressTokens<T>>::contains_key(collection_id, owner.as_sub());2620 if list_exists {2621 let mut list = <AddressTokens<T>>::get(collection_id, owner.as_sub());2622 let item_contains = list.contains(&item_index.clone());26232624 if !item_contains {2625 list.push(item_index.clone());2626 }26272628 <AddressTokens<T>>::insert(collection_id, owner.as_sub(), list);2629 } else {2630 let mut itm = Vec::new();2631 itm.push(item_index.clone());2632 <AddressTokens<T>>::insert(collection_id, owner.as_sub(), itm);2633 }26342635 Ok(())2636 }26372638 fn remove_token_index(2639 collection_id: CollectionId,2640 item_index: TokenId,2641 owner: &T::CrossAccountId,2642 ) -> DispatchResult {26432644 // update counter2645 <AccountItemCount<T>>::insert(owner.as_sub(), 2646 <AccountItemCount<T>>::get(owner.as_sub())2647 .checked_sub(1)2648 .ok_or(Error::<T>::NumOverflow)?);264926502651 let list_exists = <AddressTokens<T>>::contains_key(collection_id, owner.as_sub());2652 if list_exists {2653 let mut list = <AddressTokens<T>>::get(collection_id, owner.as_sub());2654 let item_contains = list.contains(&item_index.clone());26552656 if item_contains {2657 list.retain(|&item| item != item_index);2658 <AddressTokens<T>>::insert(collection_id, owner.as_sub(), list);2659 }2660 }26612662 Ok(())2663 }26642665 fn move_token_index(2666 collection_id: CollectionId,2667 item_index: TokenId,2668 old_owner: &T::CrossAccountId,2669 new_owner: &T::CrossAccountId,2670 ) -> DispatchResult {2671 Self::remove_token_index(collection_id, item_index, old_owner)?;2672 Self::add_token_index(collection_id, item_index, new_owner)?;26732674 Ok(())2675 }2676 2677 fn ensure_contract_owned(account: T::AccountId, contract: &T::AccountId) -> DispatchResult {2678 ensure!(<ContractOwner<T>>::get(contract) == Some(account), Error::<T>::NoPermission);26792680 Ok(())2681 }2682}26832684////////////////////////////////////////////////////////////////////////////////////////////////////2685// Economic models2686// #region26872688/// Fee multiplier.2689pub type Multiplier = FixedU128;26902691type BalanceOf<T> = <<T as pallet_transaction_payment::Config>::OnChargeTransaction as pallet_transaction_payment::OnChargeTransaction<T>>::Balance;26922693/// Require the transactor pay for themselves and maybe include a tip to gain additional priority2694/// in the queue.2695#[derive(Encode, Decode, Clone, Eq, PartialEq)]2696pub struct ChargeTransactionPayment<T: Config>(#[codec(compact)] BalanceOf<T>);26972698impl<T: Config + Send + Sync> sp_std::fmt::Debug 2699 for ChargeTransactionPayment<T>2700{2701 #[cfg(feature = "std")]2702 fn fmt(&self, f: &mut sp_std::fmt::Formatter) -> sp_std::fmt::Result {2703 write!(f, "ChargeTransactionPayment<{:?}>", self.0)2704 }2705 #[cfg(not(feature = "std"))]2706 fn fmt(&self, _: &mut sp_std::fmt::Formatter) -> sp_std::fmt::Result {2707 Ok(())2708 }2709}27102711impl<T: Config> ChargeTransactionPayment<T>2712where2713 T::Call: Dispatchable<Info=DispatchInfo, PostInfo=PostDispatchInfo> + IsSubType<Call<T>> + IsSubType<pallet_contracts::Call<T>>,2714 BalanceOf<T>: Send + Sync + From<u64> + FixedPointOperand,2715 T::AccountId: AsRef<[u8]>,2716 T::AccountId: UncheckedFrom<T::Hash>,2717{2718 fn traditional_fee(2719 len: usize,2720 info: &DispatchInfoOf<T::Call>,2721 tip: BalanceOf<T>,2722 ) -> BalanceOf<T>2723 where2724 T::Call: Dispatchable<Info = DispatchInfo>,2725 {2726 <pallet_transaction_payment::Module<T>>::compute_fee(len as u32, info, tip)2727 }27282729 fn get_priority(len: usize, info: &DispatchInfoOf<T::Call>, final_fee: BalanceOf<T>) -> TransactionPriority {2730 let weight_saturation = T::BlockWeights::get().max_block / info.weight.max(1);2731 let max_block_length = *T::BlockLength::get().max.get(DispatchClass::Normal);2732 let len_saturation = max_block_length as u64 / (len as u64).max(1);2733 let coefficient: BalanceOf<T> = weight_saturation2734 .min(len_saturation)2735 .saturated_into::<BalanceOf<T>>();2736 final_fee2737 .saturating_mul(coefficient)2738 .saturated_into::<TransactionPriority>()2739 }27402741 fn withdraw_fee(2742 &self,2743 who: &T::AccountId,2744 call: &T::Call,2745 info: &DispatchInfoOf<T::Call>,2746 len: usize,2747 ) -> Result<2748 (2749 BalanceOf<T>,2750 <<T as pallet_transaction_payment::Config>::OnChargeTransaction as pallet_transaction_payment::OnChargeTransaction<T>>::LiquidityInfo,2751 ),2752 TransactionValidityError,2753 > {2754 let tip = self.0;27552756 let fee = Self::traditional_fee(len, info, tip);27572758 // Only mess with balances if fee is not zero.2759 if fee.is_zero() {2760 return <<T as pallet_transaction_payment::Config>::OnChargeTransaction as pallet_transaction_payment::OnChargeTransaction<T>>::withdraw_fee(who, call, info, fee, tip)2761 .map(|i| (fee, i));2762 }27632764 // Determine who is paying transaction fee based on ecnomic model2765 // Parse call to extract collection ID and access collection sponsor2766 let mut sponsor: Option<T::AccountId> = (|| match IsSubType::<Call<T>>::is_sub_type(call) {2767 Some(Call::create_item(collection_id, _owner, _properties)) => {2768 let collection = <CollectionById<T>>::get(collection_id)?;27692770 // sponsor timeout2771 let block_number = <system::Module<T>>::block_number() as T::BlockNumber;27722773 let limit = collection.limits.sponsor_transfer_timeout;2774 if <CreateItemBasket<T>>::contains_key((collection_id, &who)) {2775 let last_tx_block = <CreateItemBasket<T>>::get((collection_id, &who));2776 let limit_time = last_tx_block + limit.into();2777 if block_number <= limit_time {2778 return None;2779 }2780 }2781 <CreateItemBasket<T>>::insert((collection_id, who.clone()), block_number);27822783 // check free create limit2784 if collection.limits.sponsored_data_size >= (_properties.len() as u32) {2785 collection.sponsorship.sponsor()2786 .cloned()2787 } else {2788 None2789 }2790 }2791 Some(Call::transfer(_new_owner, collection_id, item_id, _value)) => {2792 let collection = <CollectionById<T>>::get(collection_id)?;2793 2794 let mut sponsor_transfer = false;2795 if collection.sponsorship.confirmed() {27962797 let collection_limits = collection.limits;2798 let collection_mode = collection.mode;2799 2800 // sponsor timeout2801 let block_number = <system::Module<T>>::block_number() as T::BlockNumber;2802 sponsor_transfer = match collection_mode {2803 CollectionMode::NFT => {2804 2805 // get correct limit2806 let limit: u32 = if collection_limits.sponsor_transfer_timeout > 0 {2807 collection_limits.sponsor_transfer_timeout2808 } else {2809 ChainLimit::get().nft_sponsor_transfer_timeout2810 };2811 2812 let mut sponsored = true;2813 if <NftTransferBasket<T>>::contains_key(collection_id, item_id) {2814 let last_tx_block = <NftTransferBasket<T>>::get(collection_id, item_id);2815 let limit_time = last_tx_block + limit.into();2816 if block_number <= limit_time {2817 sponsored = false;2818 }2819 }2820 if sponsored {2821 <NftTransferBasket<T>>::insert(collection_id, item_id, block_number);2822 }28232824 sponsored2825 }2826 CollectionMode::Fungible(_) => {2827 2828 // get correct limit2829 let limit: u32 = if collection_limits.sponsor_transfer_timeout > 0 {2830 collection_limits.sponsor_transfer_timeout2831 } else {2832 ChainLimit::get().fungible_sponsor_transfer_timeout2833 };2834 2835 let block_number = <system::Module<T>>::block_number() as T::BlockNumber;2836 let mut sponsored = true;2837 if <FungibleTransferBasket<T>>::contains_key(collection_id, who) {2838 let last_tx_block = <FungibleTransferBasket<T>>::get(collection_id, who);2839 let limit_time = last_tx_block + limit.into();2840 if block_number <= limit_time {2841 sponsored = false;2842 }2843 }2844 if sponsored {2845 <FungibleTransferBasket<T>>::insert(collection_id, who, block_number);2846 }28472848 sponsored2849 }2850 CollectionMode::ReFungible => {2851 2852 // get correct limit2853 let limit: u32 = if collection_limits.sponsor_transfer_timeout > 0 {2854 collection_limits.sponsor_transfer_timeout2855 } else {2856 ChainLimit::get().refungible_sponsor_transfer_timeout2857 };2858 2859 let mut sponsored = true;2860 if <ReFungibleTransferBasket<T>>::contains_key(collection_id, item_id) {2861 let last_tx_block = <ReFungibleTransferBasket<T>>::get(collection_id, item_id);2862 let limit_time = last_tx_block + limit.into();2863 if block_number <= limit_time {2864 sponsored = false;2865 }2866 }2867 if sponsored {2868 <ReFungibleTransferBasket<T>>::insert(collection_id, item_id, block_number);2869 }28702871 sponsored2872 }2873 _ => {2874 false2875 },2876 };2877 }28782879 if !sponsor_transfer {2880 None2881 } else {2882 collection.sponsorship.sponsor()2883 .cloned()2884 }2885 }28862887 Some(Call::set_variable_meta_data(collection_id, item_id, data)) => {2888 let mut sponsor_metadata_changes = false;28892890 let collection = <CollectionById<T>>::get(collection_id)?;28912892 if2893 collection.sponsorship.confirmed() &&2894 // Can't sponsor fungible collection, this tx will be rejected2895 // as invalid2896 !matches!(collection.mode, CollectionMode::Fungible(_)) &&2897 data.len() <= collection.limits.sponsored_data_size as usize2898 {2899 if let Some(rate_limit) = collection.limits.sponsored_data_rate_limit {2900 let block_number = <system::Module<T>>::block_number() as T::BlockNumber;29012902 if <VariableMetaDataBasket<T>>::get(collection_id, item_id)2903 .map(|last_block| block_number - last_block > rate_limit)2904 .unwrap_or(true) 2905 {2906 sponsor_metadata_changes = true;2907 <VariableMetaDataBasket<T>>::insert(collection_id, item_id, block_number);2908 }2909 }2910 }29112912 if !sponsor_metadata_changes {2913 None2914 } else {2915 collection.sponsorship.sponsor().cloned()2916 }2917 }29182919 _ => None,2920 })();29212922 match IsSubType::<pallet_contracts::Call<T>>::is_sub_type(call) {2923 Some(pallet_contracts::Call::call(dest, _value, _gas_limit, _data)) => {29242925 let called_contract: T::AccountId = T::Lookup::lookup((*dest).clone()).unwrap_or(T::AccountId::default());29262927 let owned_contract = <ContractOwner<T>>::get(called_contract.clone()).as_ref() == Some(who);2928 let white_list_enabled = <ContractWhiteListEnabled<T>>::contains_key(called_contract.clone());2929 2930 if !owned_contract && white_list_enabled {2931 if !<ContractWhiteList<T>>::contains_key(called_contract.clone(), who) {2932 return Err(InvalidTransaction::Call.into());2933 }2934 }2935 },2936 _ => {},2937 }29382939 // Sponsor smart contracts2940 sponsor = sponsor.or_else(|| match IsSubType::<pallet_contracts::Call<T>>::is_sub_type(call) {29412942 // On instantiation: set the contract owner2943 Some(pallet_contracts::Call::instantiate(_endowment, _gas_limit, code_hash, _data, salt)) => {29442945 let new_contract_address = <pallet_contracts::Module<T>>::contract_address(2946 &who,2947 code_hash,2948 salt,2949 );2950 <ContractOwner<T>>::insert(new_contract_address.clone(), who.clone());29512952 None2953 },29542955 // On instantiation with code: set the contract owner2956 Some(pallet_contracts::Call::instantiate_with_code(_endowment, _gas_limit, _code, _data, _salt)) => {29572958 let new_contract_address = <pallet_contracts::Module<T>>::contract_address(2959 &who,2960 &T::Hashing::hash(&_code),2961 _salt,2962 );29632964 <ContractOwner<T>>::insert(new_contract_address.clone(), who.clone());29652966 None2967 }29682969 // When the contract is called, check if the sponsoring is enabled and pay fees from contract endowment if it is2970 Some(pallet_contracts::Call::call(dest, _value, _gas_limit, _data)) => {29712972 let called_contract: T::AccountId = T::Lookup::lookup((*dest).clone()).unwrap_or(T::AccountId::default());29732974 let mut sponsor_transfer = false;2975 if <ContractSponsoringRateLimit<T>>::contains_key(called_contract.clone()) {2976 let last_tx_block = <ContractSponsorBasket<T>>::get((&called_contract, &who));2977 let block_number = <system::Module<T>>::block_number() as T::BlockNumber;2978 let rate_limit = <ContractSponsoringRateLimit<T>>::get(&called_contract);2979 let limit_time = last_tx_block + rate_limit;29802981 if block_number >= limit_time {2982 <ContractSponsorBasket<T>>::insert((called_contract.clone(), who.clone()), block_number);2983 sponsor_transfer = true;2984 }2985 } else {2986 sponsor_transfer = false;2987 }2988 2989 if sponsor_transfer {2990 if <ContractSelfSponsoring<T>>::contains_key(called_contract.clone()) {2991 if <ContractSelfSponsoring<T>>::get(called_contract.clone()) {2992 return Some(called_contract);2993 }2994 }2995 }29962997 None2998 },29993000 _ => None,3001 });30023003 let who_pays_fee = sponsor.unwrap_or_else(|| who.clone());30043005 <<T as pallet_transaction_payment::Config>::OnChargeTransaction as pallet_transaction_payment::OnChargeTransaction<T>>::withdraw_fee(&who_pays_fee, call, info, fee, tip)3006 .map(|i| (fee, i))3007 }3008}300930103011impl<T: Config + Send + Sync> SignedExtension3012 for ChargeTransactionPayment<T>3013where3014 BalanceOf<T>: Send + Sync + From<u64> + FixedPointOperand,3015 T::Call: Dispatchable<Info = DispatchInfo, PostInfo = PostDispatchInfo> + IsSubType<Call<T>> + IsSubType<pallet_contracts::Call<T>>,3016 T::AccountId: AsRef<[u8]>,3017 T::AccountId: UncheckedFrom<T::Hash>,3018{3019 const IDENTIFIER: &'static str = "ChargeTransactionPayment";3020 type AccountId = T::AccountId;3021 type Call = T::Call;3022 type AdditionalSigned = ();3023 type Pre = (3024 // tip3025 BalanceOf<T>,3026 // who pays fee3027 Self::AccountId,3028 // imbalance resulting from withdrawing the fee3029 <<T as pallet_transaction_payment::Config>::OnChargeTransaction as pallet_transaction_payment::OnChargeTransaction<T>>::LiquidityInfo,3030 );3031 fn additional_signed(&self) -> sp_std::result::Result<(), TransactionValidityError> {3032 Ok(())3033 }30343035 fn validate(3036 &self,3037 who: &Self::AccountId,3038 call: &Self::Call,3039 info: &DispatchInfoOf<Self::Call>,3040 len: usize,3041 ) -> TransactionValidity {3042 let (fee, _) = self.withdraw_fee(who, call, info, len)?;3043 Ok(ValidTransaction {3044 priority: Self::get_priority(len, info, fee),3045 ..Default::default()3046 })3047 }30483049 fn pre_dispatch(3050 self,3051 who: &Self::AccountId,3052 call: &Self::Call,3053 info: &DispatchInfoOf<Self::Call>,3054 len: usize,3055 ) -> Result<Self::Pre, TransactionValidityError> {3056 let (_fee, imbalance) = self.withdraw_fee(who, call, info, len)?;3057 Ok((self.0, who.clone(), imbalance))3058 }30593060 fn post_dispatch(3061 pre: Self::Pre,3062 info: &DispatchInfoOf<Self::Call>,3063 post_info: &PostDispatchInfoOf<Self::Call>,3064 len: usize,3065 _result: &DispatchResult,3066 ) -> Result<(), TransactionValidityError> {3067 let (tip, who, imbalance) = pre;3068 let actual_fee = pallet_transaction_payment::Module::<T>::compute_actual_fee(3069 len as u32,3070 info,3071 post_info,3072 tip,3073 );3074 <T as pallet_transaction_payment::Config>::OnChargeTransaction::correct_and_deposit_fee(&who, info, post_info, actual_fee, tip, imbalance)?;3075 Ok(())3076 }3077}30783079// #endregion30803081sp_api::decl_runtime_apis! {3082 pub trait NftApi {3083 /// Used for ethereum integration3084 fn eth_contract_code(account: H160) -> Option<Vec<u8>>;3085 }3086}1//2// This file is subject to the terms and conditions defined in3// file 'LICENSE', which is part of this source code package.4//56#![recursion_limit = "1024"]78#![cfg_attr(not(feature = "std"), no_std)]91011pub use serde::{Serialize, Deserialize};1213use core::ops::{Deref, DerefMut};14use codec::{Decode, Encode};15pub use frame_support::{16 construct_runtime, decl_event, decl_module, decl_storage, decl_error,17 dispatch::DispatchResult,18 ensure, fail, parameter_types,19 traits::{20 Currency, ExistenceRequirement, Get, Imbalance, KeyOwnerProofSystem, OnUnbalanced,21 Randomness, IsSubType, WithdrawReasons,22 },23 weights::{24 constants::{BlockExecutionWeight, ExtrinsicBaseWeight, RocksDbWeight, WEIGHT_PER_SECOND},25 DispatchInfo, GetDispatchInfo, IdentityFee, Pays, PostDispatchInfo, Weight,26 WeightToFeePolynomial, DispatchClass,27 },28 StorageValue,29 transactional,30};3132use frame_system::{self as system, ensure_signed, ensure_root};33use sp_core::{H160, H256};34use sp_runtime::sp_std::prelude::Vec;35use sp_runtime::{36 traits::{37 Hash, DispatchInfoOf, Dispatchable, PostDispatchInfoOf, Saturating, SaturatedConversion, SignedExtension, Zero,38 },39 transaction_validity::{40 TransactionPriority, InvalidTransaction, TransactionValidity, TransactionValidityError, ValidTransaction,41 },42 FixedPointOperand, FixedU128,43};44use sp_runtime::traits::StaticLookup;45use pallet_contracts::chain_extension::UncheckedFrom;46use pallet_ethereum::EthereumTransactionSender;47use pallet_transaction_payment::OnChargeTransaction;4849#[cfg(test)]50mod mock;5152#[cfg(test)]53mod tests;5455mod default_weights;56mod eth;5758pub use eth::NftErcSupport;59pub use eth::account::*;60use eth::erc::{ERC20Events, ERC721Events};6162pub const MAX_DECIMAL_POINTS: DecimalPoints = 30;63pub const MAX_REFUNGIBLE_PIECES: u128 = 1_000_000_000_000_000_000_000;64pub const MAX_SPONSOR_TIMEOUT: u32 = 10_368_000;65pub const MAX_TOKEN_OWNERSHIP: u32 = 10_000_000;6667// Structs68// #region6970pub type CollectionId = u32;71pub type TokenId = u32;72pub type DecimalPoints = u8;7374#[derive(Encode, Decode, Eq, Debug, Clone, PartialEq)]75#[derive(Serialize, Deserialize)]76pub enum CollectionMode {77 Invalid,78 NFT,79 // decimal points80 Fungible(DecimalPoints),81 ReFungible,82}8384impl Default for CollectionMode {85 fn default() -> Self {86 Self::Invalid87 }88}8990impl Into<u8> for CollectionMode {91 fn into(self) -> u8 {92 match self {93 CollectionMode::Invalid => 0,94 CollectionMode::NFT => 1,95 CollectionMode::Fungible(_) => 2,96 CollectionMode::ReFungible => 3,97 }98 }99}100101#[derive(Encode, Decode, Eq, Debug, Clone, PartialEq)]102#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]103pub enum AccessMode {104 Normal,105 WhiteList,106}107impl Default for AccessMode {108 fn default() -> Self {109 Self::Normal110 }111}112113#[derive(Encode, Decode, Eq, Debug, Clone, PartialEq)]114#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]115pub enum SchemaVersion {116 ImageURL,117 Unique,118}119impl Default for SchemaVersion {120 fn default() -> Self {121 Self::ImageURL122 }123}124125#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]126#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]127pub struct Ownership<AccountId> {128 pub owner: AccountId,129 pub fraction: u128,130}131132#[derive(Encode, Decode, Debug, Clone, PartialEq)]133#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]134pub enum SponsorshipState<AccountId> {135 /// The fees are applied to the transaction sender136 Disabled,137 Unconfirmed(AccountId),138 /// Transactions are sponsored by specified account139 Confirmed(AccountId),140}141142impl<AccountId> SponsorshipState<AccountId> {143 fn sponsor(&self) -> Option<&AccountId> {144 match self {145 Self::Confirmed(sponsor) => Some(sponsor),146 _ => None,147 }148 }149150 fn pending_sponsor(&self) -> Option<&AccountId> {151 match self {152 Self::Unconfirmed(sponsor) | Self::Confirmed(sponsor) => Some(sponsor),153 _ => None,154 }155 }156157 fn confirmed(&self) -> bool {158 matches!(self, Self::Confirmed(_))159 }160}161162impl<T> Default for SponsorshipState<T> {163 fn default() -> Self {164 Self::Disabled165 }166}167168#[derive(Encode, Decode, Clone, PartialEq)]169#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]170pub struct Collection<T: Config> {171 pub owner: T::AccountId,172 pub mode: CollectionMode,173 pub access: AccessMode,174 pub decimal_points: DecimalPoints,175 pub name: Vec<u16>, // 64 include null escape char176 pub description: Vec<u16>, // 256 include null escape char177 pub token_prefix: Vec<u8>, // 16 include null escape char178 pub mint_mode: bool,179 pub offchain_schema: Vec<u8>,180 pub schema_version: SchemaVersion,181 pub sponsorship: SponsorshipState<T::AccountId>,182 pub limits: CollectionLimits<T::BlockNumber>, // Collection private restrictions 183 pub variable_on_chain_schema: Vec<u8>, //184 pub const_on_chain_schema: Vec<u8>, //185}186187pub struct CollectionHandle<T: Config> {188 pub id: CollectionId,189 collection: Collection<T>,190 logs: eth::log::LogRecorder,191}192impl<T: Config> CollectionHandle<T> {193 pub fn get(id: CollectionId) -> Option<Self> {194 <CollectionById<T>>::get(id)195 .map(|collection| Self {196 id,197 collection,198 logs: eth::log::LogRecorder::default(),199 })200 }201 pub fn log(&self, log: impl evm_coder::ToLog) {202 self.logs.log(log.to_log(self.evm_address))203 }204 pub fn into_inner(self) -> Collection<T> {205 self.collection.clone()206 }207}208209impl<T: Config> Deref for CollectionHandle<T> {210 type Target = Collection<T>;211212 fn deref(&self) -> &Self::Target {213 &self.collection214 }215}216217impl<T: Config> DerefMut for CollectionHandle<T> {218 fn deref_mut(&mut self) -> &mut Self::Target {219 &mut self.collection220 }221}222223#[derive(Encode, Decode, Debug, Clone, PartialEq)]224#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]225pub struct NftItemType<AccountId> {226 pub owner: AccountId,227 pub const_data: Vec<u8>,228 pub variable_data: Vec<u8>,229}230231#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]232#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]233pub struct FungibleItemType {234 pub value: u128,235}236237#[derive(Encode, Decode, Debug, Clone, PartialEq)]238#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]239pub struct ReFungibleItemType<AccountId> {240 pub owner: Vec<Ownership<AccountId>>,241 pub const_data: Vec<u8>,242 pub variable_data: Vec<u8>,243}244245// #[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]246// #[cfg_attr(feature = "std", derive(Serialize, Deserialize))]247// pub struct VestingItem<AccountId, Moment> {248// pub sender: AccountId,249// pub recipient: AccountId,250// pub collection_id: CollectionId,251// pub item_id: TokenId,252// pub amount: u64,253// pub vesting_date: Moment,254// }255256#[derive(Encode, Decode, Debug, Clone, PartialEq)]257#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]258pub struct CollectionLimits<BlockNumber: Encode + Decode> {259 pub account_token_ownership_limit: u32,260 pub sponsored_data_size: u32,261 /// None - setVariableMetadata is not sponsored262 /// Some(v) - setVariableMetadata is sponsored 263 /// if there is v block between txs264 pub sponsored_data_rate_limit: Option<BlockNumber>,265 pub token_limit: u32,266267 // Timeouts for item types in passed blocks268 pub sponsor_transfer_timeout: u32,269 pub owner_can_transfer: bool,270 pub owner_can_destroy: bool,271}272273impl<BlockNumber: Encode + Decode> Default for CollectionLimits<BlockNumber> {274 fn default() -> Self {275 Self { 276 account_token_ownership_limit: 10_000_000, 277 token_limit: u32::max_value(),278 sponsored_data_size: u32::MAX, 279 sponsored_data_rate_limit: None,280 sponsor_transfer_timeout: 14400,281 owner_can_transfer: true,282 owner_can_destroy: true283 }284 }285}286287#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]288#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]289pub struct ChainLimits {290 pub collection_numbers_limit: u32,291 pub account_token_ownership_limit: u32,292 pub collections_admins_limit: u64,293 pub custom_data_limit: u32,294295 // Timeouts for item types in passed blocks296 pub nft_sponsor_transfer_timeout: u32,297 pub fungible_sponsor_transfer_timeout: u32,298 pub refungible_sponsor_transfer_timeout: u32,299300 // Schema limits301 pub offchain_schema_limit: u32,302 pub variable_on_chain_schema_limit: u32,303 pub const_on_chain_schema_limit: u32,304}305306pub trait WeightInfo {307 fn create_collection() -> Weight;308 fn destroy_collection() -> Weight;309 fn add_to_white_list() -> Weight;310 fn remove_from_white_list() -> Weight;311 fn set_public_access_mode() -> Weight;312 fn set_mint_permission() -> Weight;313 fn change_collection_owner() -> Weight;314 fn add_collection_admin() -> Weight;315 fn remove_collection_admin() -> Weight;316 fn set_collection_sponsor() -> Weight;317 fn confirm_sponsorship() -> Weight;318 fn remove_collection_sponsor() -> Weight;319 fn create_item(s: usize) -> Weight;320 fn burn_item() -> Weight;321 fn transfer() -> Weight;322 fn approve() -> Weight;323 fn transfer_from() -> Weight;324 fn set_offchain_schema() -> Weight;325 fn set_const_on_chain_schema() -> Weight;326 fn set_variable_on_chain_schema() -> Weight;327 fn set_variable_meta_data() -> Weight;328 fn enable_contract_sponsoring() -> Weight;329 fn set_schema_version() -> Weight;330 fn set_chain_limits() -> Weight;331 fn set_contract_sponsoring_rate_limit() -> Weight;332 fn set_variable_meta_data_sponsoring_rate_limit() -> Weight;333 fn toggle_contract_white_list() -> Weight;334 fn add_to_contract_white_list() -> Weight;335 fn remove_from_contract_white_list() -> Weight;336 fn set_collection_limits() -> Weight;337}338339#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]340#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]341pub struct CreateNftData {342 pub const_data: Vec<u8>,343 pub variable_data: Vec<u8>,344}345346#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]347#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]348pub struct CreateFungibleData {349 pub value: u128,350}351352#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]353#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]354pub struct CreateReFungibleData {355 pub const_data: Vec<u8>,356 pub variable_data: Vec<u8>,357 pub pieces: u128,358}359360#[derive(Encode, Decode, Debug, Clone, PartialEq)]361#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]362pub enum CreateItemData {363 NFT(CreateNftData),364 Fungible(CreateFungibleData),365 ReFungible(CreateReFungibleData),366}367368impl CreateItemData {369 pub fn len(&self) -> usize {370 let len = match self {371 CreateItemData::NFT(data) => data.variable_data.len() + data.const_data.len(),372 CreateItemData::ReFungible(data) => data.variable_data.len() + data.const_data.len(),373 _ => 0374 };375 376 return len;377 }378}379380impl From<CreateNftData> for CreateItemData {381 fn from(item: CreateNftData) -> Self {382 CreateItemData::NFT(item)383 }384}385386impl From<CreateReFungibleData> for CreateItemData {387 fn from(item: CreateReFungibleData) -> Self {388 CreateItemData::ReFungible(item)389 }390}391392impl From<CreateFungibleData> for CreateItemData {393 fn from(item: CreateFungibleData) -> Self {394 CreateItemData::Fungible(item)395 }396}397398399decl_error! {400 /// Error for non-fungible-token module.401 pub enum Error for Module<T: Config> {402 /// Total collections bound exceeded.403 TotalCollectionsLimitExceeded,404 /// Decimal_points parameter must be lower than MAX_DECIMAL_POINTS constant, currently it is 30.405 CollectionDecimalPointLimitExceeded, 406 /// Collection name can not be longer than 63 char.407 CollectionNameLimitExceeded, 408 /// Collection description can not be longer than 255 char.409 CollectionDescriptionLimitExceeded, 410 /// Token prefix can not be longer than 15 char.411 CollectionTokenPrefixLimitExceeded,412 /// This collection does not exist.413 CollectionNotFound,414 /// Item not exists.415 TokenNotFound,416 /// Admin not found417 AdminNotFound,418 /// Arithmetic calculation overflow.419 NumOverflow, 420 /// Account already has admin role.421 AlreadyAdmin, 422 /// You do not own this collection.423 NoPermission,424 /// This address is not set as sponsor, use setCollectionSponsor first.425 ConfirmUnsetSponsorFail,426 /// Collection is not in mint mode.427 PublicMintingNotAllowed,428 /// Sender parameter and item owner must be equal.429 MustBeTokenOwner,430 /// Item balance not enough.431 TokenValueTooLow,432 /// Size of item is too large.433 NftSizeLimitExceeded,434 /// No approve found435 ApproveNotFound,436 /// Requested value more than approved.437 TokenValueNotEnough,438 /// Only approved addresses can call this method.439 ApproveRequired,440 /// Address is not in white list.441 AddresNotInWhiteList,442 /// Number of collection admins bound exceeded.443 CollectionAdminsLimitExceeded,444 /// Owned tokens by a single address bound exceeded.445 AddressOwnershipLimitExceeded,446 /// Length of items properties must be greater than 0.447 EmptyArgument,448 /// const_data exceeded data limit.449 TokenConstDataLimitExceeded,450 /// variable_data exceeded data limit.451 TokenVariableDataLimitExceeded,452 /// Not NFT item data used to mint in NFT collection.453 NotNftDataUsedToMintNftCollectionToken,454 /// Not Fungible item data used to mint in Fungible collection.455 NotFungibleDataUsedToMintFungibleCollectionToken,456 /// Not Re Fungible item data used to mint in Re Fungible collection.457 NotReFungibleDataUsedToMintReFungibleCollectionToken,458 /// Unexpected collection type.459 UnexpectedCollectionType,460 /// Can't store metadata in fungible tokens.461 CantStoreMetadataInFungibleTokens,462 /// Collection token limit exceeded463 CollectionTokenLimitExceeded,464 /// Account token limit exceeded per collection465 AccountTokenLimitExceeded,466 /// Collection limit bounds per collection exceeded467 CollectionLimitBoundsExceeded,468 /// Tried to enable permissions which are only permitted to be disabled469 OwnerPermissionsCantBeReverted,470 /// Schema data size limit bound exceeded471 SchemaDataLimitExceeded,472 /// Maximum refungibility exceeded473 WrongRefungiblePieces,474 /// createRefungible should be called with one owner475 BadCreateRefungibleCall,476 }477}478479pub trait Config: system::Config + Sized + pallet_transaction_payment::Config + pallet_contracts::Config {480 type Event: From<Event<Self>> + Into<<Self as system::Config>::Event>;481482 /// Weight information for extrinsics in this pallet.483 type WeightInfo: WeightInfo;484485 type EvmAddressMapping: pallet_evm::AddressMapping<Self::AccountId>;486 type EvmBackwardsAddressMapping: EvmBackwardsAddressMapping<Self::AccountId>;487 type EvmWithdrawOrigin: pallet_evm::EnsureAddressOrigin<Self::Origin, Success = Self::AccountId>;488489 type CrossAccountId: CrossAccountId<Self::AccountId>;490 type Currency: Currency<Self::AccountId>;491 type CollectionCreationPrice: Get<<<Self as Config>::Currency as Currency<Self::AccountId>>::Balance>;492 type TreasuryAccountId: Get<Self::AccountId>;493494 type EthereumChainId: Get<u64>;495 type EthereumTransactionSender: pallet_ethereum::EthereumTransactionSender;496}497498#[cfg(feature = "runtime-benchmarks")]499mod benchmarking;500501// #endregion502503// # Used definitions504//505// ## User control levels506//507// chain-controlled - key is uncontrolled by user508// i.e autoincrementing index509// can use non-cryptographic hash510// real - key is controlled by user511// but it is hard to generate enough colliding values, i.e owner of signed txs512// can use non-cryptographic hash513// controlled - key is completly controlled by users514// i.e maps with mutable keys515// should use cryptographic hash516//517// ## User control level downgrade reasons518//519// ?1 - chain-controlled -> controlled520// collections/tokens can be destroyed, resulting in massive holes521// ?2 - chain-controlled -> controlled522// same as ?1, but can be only added, resulting in easier exploitation523// ?3 - real -> controlled524// no confirmation required, so addresses can be easily generated525decl_storage! {526 trait Store for Module<T: Config> as Nft {527528 //#region Private members529 /// Id of next collection530 CreatedCollectionCount: u32;531 /// Used for migrations532 ChainVersion: u64;533 /// Id of last collection token534 /// Collection id (controlled?1)535 ItemListIndex: map hasher(blake2_128_concat) CollectionId => TokenId;536 //#endregion537538 //#region Chain limits struct539 pub ChainLimit get(fn chain_limit) config(): ChainLimits;540 //#endregion541542 //#region Bound counters543 /// Amount of collections destroyed, used for total amount tracking with544 /// CreatedCollectionCount545 DestroyedCollectionCount: u32;546 /// Total amount of account owned tokens (NFTs + RFTs + unique fungibles)547 /// Account id (real)548 pub AccountItemCount get(fn account_item_count): map hasher(twox_64_concat) T::AccountId => u32;549 //#endregion550551 //#region Basic collections552 /// Collection info553 /// Collection id (controlled?1)554 pub CollectionById get(fn collection_id) config(): map hasher(blake2_128_concat) CollectionId => Option<Collection<T>> = None;555 /// List of collection admins556 /// Collection id (controlled?2)557 pub AdminList get(fn admin_list_collection): map hasher(blake2_128_concat) CollectionId => Vec<T::CrossAccountId>;558 /// Whitelisted collection users559 /// Collection id (controlled?2), user id (controlled?3)560 pub WhiteList get(fn white_list): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) T::AccountId => bool;561 //#endregion562563 /// How many of collection items user have564 /// Collection id (controlled?2), account id (real)565 pub Balance get(fn balance_count): double_map hasher(blake2_128_concat) CollectionId, hasher(twox_64_concat) T::AccountId => u128;566567 /// Amount of items which spender can transfer out of owners account (via transferFrom)568 /// Collection id (controlled?2), (token id (controlled ?2) + owner account id (real) + spender account id (controlled?3))569 /// TODO: Off chain worker should remove from this map when token gets removed570 pub Allowances get(fn approved): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) (TokenId, T::AccountId, T::AccountId) => u128;571572 //#region Item collections573 /// Collection id (controlled?2), token id (controlled?1)574 pub NftItemList get(fn nft_item_id) config(): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => Option<NftItemType<T::CrossAccountId>>;575 /// Collection id (controlled?2), owner (controlled?2)576 pub FungibleItemList get(fn fungible_item_id) config(): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) T::AccountId => FungibleItemType;577 /// Collection id (controlled?2), token id (controlled?1)578 pub ReFungibleItemList get(fn refungible_item_id) config(): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => Option<ReFungibleItemType<T::CrossAccountId>>;579 //#endregion580581 //#region Index list582 /// Collection id (controlled?2), tokens owner (controlled?2)583 pub AddressTokens get(fn address_tokens): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) T::AccountId => Vec<TokenId>;584 //#endregion585586 //#region Tokens transfer rate limit baskets587 /// (Collection id (controlled?2), who created (real))588 /// TODO: Off chain worker should remove from this map when collection gets removed589 pub CreateItemBasket get(fn create_item_basket): map hasher(blake2_128_concat) (CollectionId, T::AccountId) => T::BlockNumber;590 /// Collection id (controlled?2), token id (controlled?2)591 pub NftTransferBasket get(fn nft_transfer_basket): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => T::BlockNumber;592 /// Collection id (controlled?2), owning user (real)593 pub FungibleTransferBasket get(fn fungible_transfer_basket): double_map hasher(blake2_128_concat) CollectionId, hasher(twox_64_concat) T::AccountId => T::BlockNumber;594 /// Collection id (controlled?2), token id (controlled?2)595 pub ReFungibleTransferBasket get(fn refungible_transfer_basket): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => T::BlockNumber;596 //#endregion597598 /// Variable metadata sponsoring599 /// Collection id (controlled?2), token id (controlled?2)600 pub VariableMetaDataBasket get(fn variable_meta_data_basket): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => Option<T::BlockNumber> = None;601 602 //#region Contract Sponsorship and Ownership603 /// Contract address (real)604 pub ContractOwner get(fn contract_owner): map hasher(twox_64_concat) T::AccountId => Option<T::AccountId>;605 /// Contract address (real)606 pub ContractSelfSponsoring get(fn contract_self_sponsoring): map hasher(twox_64_concat) T::AccountId => bool;607 /// (Contract address(real), caller (real))608 pub ContractSponsorBasket get(fn contract_sponsor_basket): map hasher(twox_64_concat) (T::AccountId, T::AccountId) => T::BlockNumber;609 /// Contract address (real)610 pub ContractSponsoringRateLimit get(fn contract_sponsoring_rate_limit): map hasher(twox_64_concat) T::AccountId => T::BlockNumber;611 /// Contract address (real)612 pub ContractWhiteListEnabled get(fn contract_white_list_enabled): map hasher(twox_64_concat) T::AccountId => bool; 613 /// Contract address (real) => Whitelisted user (controlled?3)614 pub ContractWhiteList get(fn contract_white_list): double_map hasher(twox_64_concat) T::AccountId, hasher(blake2_128_concat) T::AccountId => bool; 615 //#endregion616 }617 add_extra_genesis {618 build(|config: &GenesisConfig<T>| {619 // Modification of storage620 for (_num, _c) in &config.collection_id {621 <Module<T>>::init_collection(_c);622 }623624 for (_num, _c, _i) in &config.nft_item_id {625 <Module<T>>::init_nft_token(*_c, _i);626 }627628 for (collection_id, account_id, fungible_item) in &config.fungible_item_id {629 <Module<T>>::init_fungible_token(*collection_id, &T::CrossAccountId::from_sub(account_id.clone()), fungible_item);630 }631632 for (_num, _c, _i) in &config.refungible_item_id {633 <Module<T>>::init_refungible_token(*_c, _i);634 }635 })636 }637}638639decl_event!(640 pub enum Event<T>641 where642 AccountId = <T as frame_system::Config>::AccountId,643 CrossAccountId = <T as Config>::CrossAccountId,644 {645 /// New collection was created646 /// 647 /// # Arguments648 /// 649 /// * collection_id: Globally unique identifier of newly created collection.650 /// 651 /// * mode: [CollectionMode] converted into u8.652 /// 653 /// * account_id: Collection owner.654 CollectionCreated(CollectionId, u8, AccountId),655656 /// New item was created.657 /// 658 /// # Arguments659 /// 660 /// * collection_id: Id of the collection where item was created.661 /// 662 /// * item_id: Id of an item. Unique within the collection.663 ///664 /// * recipient: Owner of newly created item 665 ItemCreated(CollectionId, TokenId, CrossAccountId),666667 /// Collection item was burned.668 /// 669 /// # Arguments670 /// 671 /// collection_id.672 /// 673 /// item_id: Identifier of burned NFT.674 ItemDestroyed(CollectionId, TokenId),675676 /// Item was transferred677 ///678 /// * collection_id: Id of collection to which item is belong679 ///680 /// * item_id: Id of an item681 ///682 /// * sender: Original owner of item683 ///684 /// * recipient: New owner of item685 ///686 /// * amount: Always 1 for NFT687 Transfer(CollectionId, TokenId, CrossAccountId, CrossAccountId, u128),688689 /// * collection_id690 ///691 /// * item_id692 ///693 /// * sender694 ///695 /// * spender696 ///697 /// * amount698 Approved(CollectionId, TokenId, CrossAccountId, CrossAccountId, u128),699 }700);701702decl_module! {703 pub struct Module<T: Config> for enum Call 704 where 705 origin: T::Origin706 {707 fn deposit_event() = default;708 type Error = Error<T>;709710 fn on_initialize(now: T::BlockNumber) -> Weight {711 0712 }713714 /// 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.715 /// 716 /// # Permissions717 /// 718 /// * Anyone.719 /// 720 /// # Arguments721 /// 722 /// * collection_name: UTF-16 string with collection name (limit 64 characters), will be stored as zero-terminated.723 /// 724 /// * collection_description: UTF-16 string with collection description (limit 256 characters), will be stored as zero-terminated.725 /// 726 /// * token_prefix: UTF-8 string with token prefix.727 /// 728 /// * mode: [CollectionMode] collection type and type dependent data.729 // returns collection ID730 #[weight = <T as Config>::WeightInfo::create_collection()]731 #[transactional]732 pub fn create_collection(origin,733 collection_name: Vec<u16>,734 collection_description: Vec<u16>,735 token_prefix: Vec<u8>,736 mode: CollectionMode) -> DispatchResult {737738 // Anyone can create a collection739 let who = ensure_signed(origin)?;740741 // Take a (non-refundable) deposit of collection creation742 let mut imbalance = <<<T as Config>::Currency as Currency<T::AccountId>>::PositiveImbalance>::zero();743 imbalance.subsume(<<T as Config>::Currency as Currency<T::AccountId>>::deposit_creating(744 &T::TreasuryAccountId::get(),745 T::CollectionCreationPrice::get(),746 ));747 <T as Config>::Currency::settle(748 &who,749 imbalance,750 WithdrawReasons::TRANSFER,751 ExistenceRequirement::KeepAlive,752 ).map_err(|_| Error::<T>::NoPermission)?;753754 let decimal_points = match mode {755 CollectionMode::Fungible(points) => points,756 _ => 0757 };758759 let chain_limit = ChainLimit::get();760761 let created_count = CreatedCollectionCount::get();762 let destroyed_count = DestroyedCollectionCount::get();763764 // bound Total number of collections765 ensure!(created_count - destroyed_count < chain_limit.collection_numbers_limit, Error::<T>::TotalCollectionsLimitExceeded);766767 // check params768 ensure!(decimal_points <= MAX_DECIMAL_POINTS, Error::<T>::CollectionDecimalPointLimitExceeded);769 ensure!(collection_name.len() <= 64, Error::<T>::CollectionNameLimitExceeded);770 ensure!(collection_description.len() <= 256, Error::<T>::CollectionDescriptionLimitExceeded);771 ensure!(token_prefix.len() <= 16, Error::<T>::CollectionTokenPrefixLimitExceeded);772773 // Generate next collection ID774 let next_id = created_count775 .checked_add(1)776 .ok_or(Error::<T>::NumOverflow)?;777778 CreatedCollectionCount::put(next_id);779780 let limits = CollectionLimits {781 sponsored_data_size: chain_limit.custom_data_limit,782 ..Default::default()783 };784785 // Create new collection786 let new_collection = Collection {787 owner: who.clone(),788 name: collection_name,789 mode: mode.clone(),790 mint_mode: false,791 access: AccessMode::Normal,792 description: collection_description,793 decimal_points: decimal_points,794 token_prefix: token_prefix,795 offchain_schema: Vec::new(),796 schema_version: SchemaVersion::ImageURL,797 sponsorship: SponsorshipState::Disabled,798 variable_on_chain_schema: Vec::new(),799 const_on_chain_schema: Vec::new(),800 limits,801 };802803 // Add new collection to map804 <CollectionById<T>>::insert(next_id, new_collection);805806 // call event807 Self::deposit_event(RawEvent::CollectionCreated(next_id, mode.into(), who));808809 Ok(())810 }811812 /// **DANGEROUS**: Destroys collection and all NFTs within this collection. Users irrecoverably lose their assets and may lose real money.813 /// 814 /// # Permissions815 /// 816 /// * Collection Owner.817 /// 818 /// # Arguments819 /// 820 /// * collection_id: collection to destroy.821 #[weight = <T as Config>::WeightInfo::destroy_collection()]822 #[transactional]823 pub fn destroy_collection(origin, collection_id: CollectionId) -> DispatchResult {824825 let sender = ensure_signed(origin)?;826 let collection = Self::get_collection(collection_id)?;827 Self::check_owner_permissions(&collection, &sender)?;828 if !collection.limits.owner_can_destroy {829 fail!(Error::<T>::NoPermission);830 }831832 <AddressTokens<T>>::remove_prefix(collection_id);833 <Allowances<T>>::remove_prefix(collection_id);834 <Balance<T>>::remove_prefix(collection_id);835 <ItemListIndex>::remove(collection_id);836 <AdminList<T>>::remove(collection_id);837 <CollectionById<T>>::remove(collection_id);838 <WhiteList<T>>::remove_prefix(collection_id);839840 <NftItemList<T>>::remove_prefix(collection_id);841 <FungibleItemList<T>>::remove_prefix(collection_id);842 <ReFungibleItemList<T>>::remove_prefix(collection_id);843844 <NftTransferBasket<T>>::remove_prefix(collection_id);845 <FungibleTransferBasket<T>>::remove_prefix(collection_id);846 <ReFungibleTransferBasket<T>>::remove_prefix(collection_id);847848 <VariableMetaDataBasket<T>>::remove_prefix(collection_id);849850 DestroyedCollectionCount::put(DestroyedCollectionCount::get()851 .checked_add(1)852 .ok_or(Error::<T>::NumOverflow)?);853854 Ok(())855 }856857 /// Add an address to white list.858 /// 859 /// # Permissions860 /// 861 /// * Collection Owner862 /// * Collection Admin863 /// 864 /// # Arguments865 /// 866 /// * collection_id.867 /// 868 /// * address.869 #[weight = <T as Config>::WeightInfo::add_to_white_list()]870 #[transactional]871 pub fn add_to_white_list(origin, collection_id: CollectionId, address: T::CrossAccountId) -> DispatchResult{872873 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);874 let collection = Self::get_collection(collection_id)?;875876 Self::toggle_white_list_internal(877 &sender,878 &collection,879 &address,880 true,881 )?;882883 Ok(())884 }885886 /// Remove an address from white list.887 /// 888 /// # Permissions889 /// 890 /// * Collection Owner891 /// * Collection Admin892 /// 893 /// # Arguments894 /// 895 /// * collection_id.896 /// 897 /// * address.898 #[weight = <T as Config>::WeightInfo::remove_from_white_list()]899 #[transactional]900 pub fn remove_from_white_list(origin, collection_id: CollectionId, address: T::CrossAccountId) -> DispatchResult{901902 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);903 let collection = Self::get_collection(collection_id)?;904905 Self::toggle_white_list_internal(906 &sender,907 &collection,908 &address,909 false,910 )?;911912 Ok(())913 }914915 /// Toggle between normal and white list access for the methods with access for `Anyone`.916 /// 917 /// # Permissions918 /// 919 /// * Collection Owner.920 /// 921 /// # Arguments922 /// 923 /// * collection_id.924 /// 925 /// * mode: [AccessMode]926 #[weight = <T as Config>::WeightInfo::set_public_access_mode()]927 #[transactional]928 pub fn set_public_access_mode(origin, collection_id: CollectionId, mode: AccessMode) -> DispatchResult929 {930 let sender = ensure_signed(origin)?;931932 let mut target_collection = Self::get_collection(collection_id)?;933 Self::check_owner_permissions(&target_collection, &sender)?;934 target_collection.access = mode;935 Self::save_collection(target_collection);936937 Ok(())938 }939940 /// Allows Anyone to create tokens if:941 /// * White List is enabled, and942 /// * Address is added to white list, and943 /// * This method was called with True parameter944 /// 945 /// # Permissions946 /// * Collection Owner947 ///948 /// # Arguments949 /// 950 /// * collection_id.951 /// 952 /// * mint_permission: Boolean parameter. If True, allows minting to Anyone with conditions above.953 #[weight = <T as Config>::WeightInfo::set_mint_permission()]954 #[transactional]955 pub fn set_mint_permission(origin, collection_id: CollectionId, mint_permission: bool) -> DispatchResult956 {957 let sender = ensure_signed(origin)?;958959 let mut target_collection = Self::get_collection(collection_id)?;960 Self::check_owner_permissions(&target_collection, &sender)?;961 target_collection.mint_mode = mint_permission;962 Self::save_collection(target_collection);963964 Ok(())965 }966967 /// Change the owner of the collection.968 /// 969 /// # Permissions970 /// 971 /// * Collection Owner.972 /// 973 /// # Arguments974 /// 975 /// * collection_id.976 /// 977 /// * new_owner.978 #[weight = <T as Config>::WeightInfo::change_collection_owner()]979 #[transactional]980 pub fn change_collection_owner(origin, collection_id: CollectionId, new_owner: T::AccountId) -> DispatchResult {981982 let sender = ensure_signed(origin)?;983 let mut target_collection = Self::get_collection(collection_id)?;984 Self::check_owner_permissions(&target_collection, &sender)?;985 target_collection.owner = new_owner;986 Self::save_collection(target_collection);987988 Ok(())989 }990991 /// Adds an admin of the Collection.992 /// 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. 993 /// 994 /// # Permissions995 /// 996 /// * Collection Owner.997 /// * Collection Admin.998 /// 999 /// # Arguments1000 /// 1001 /// * collection_id: ID of the Collection to add admin for.1002 /// 1003 /// * new_admin_id: Address of new admin to add.1004 #[weight = <T as Config>::WeightInfo::add_collection_admin()]1005 #[transactional]1006 pub fn add_collection_admin(origin, collection_id: CollectionId, new_admin_id: T::CrossAccountId) -> DispatchResult {1007 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1008 let collection = Self::get_collection(collection_id)?;1009 Self::check_owner_or_admin_permissions(&collection, &sender)?;1010 let mut admin_arr = <AdminList<T>>::get(collection_id);10111012 match admin_arr.binary_search(&new_admin_id) {1013 Ok(_) => {},1014 Err(idx) => {1015 let limits = ChainLimit::get();1016 ensure!(admin_arr.len() < limits.collections_admins_limit as usize, Error::<T>::CollectionAdminsLimitExceeded);1017 admin_arr.insert(idx, new_admin_id);1018 <AdminList<T>>::insert(collection_id, admin_arr);1019 }1020 }1021 Ok(())1022 }10231024 /// 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.1025 ///1026 /// # Permissions1027 /// 1028 /// * Collection Owner.1029 /// * Collection Admin.1030 /// 1031 /// # Arguments1032 /// 1033 /// * collection_id: ID of the Collection to remove admin for.1034 /// 1035 /// * account_id: Address of admin to remove.1036 #[weight = <T as Config>::WeightInfo::remove_collection_admin()]1037 #[transactional]1038 pub fn remove_collection_admin(origin, collection_id: CollectionId, account_id: T::CrossAccountId) -> DispatchResult {1039 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1040 let collection = Self::get_collection(collection_id)?;1041 Self::check_owner_or_admin_permissions(&collection, &sender)?;1042 let mut admin_arr = <AdminList<T>>::get(collection_id);10431044 match admin_arr.binary_search(&account_id) {1045 Ok(idx) => {1046 admin_arr.remove(idx);1047 <AdminList<T>>::insert(collection_id, admin_arr);1048 },1049 Err(_) => {}1050 }1051 Ok(())1052 }10531054 /// # Permissions1055 /// 1056 /// * Collection Owner1057 /// 1058 /// # Arguments1059 /// 1060 /// * collection_id.1061 /// 1062 /// * new_sponsor.1063 #[weight = <T as Config>::WeightInfo::set_collection_sponsor()]1064 #[transactional]1065 pub fn set_collection_sponsor(origin, collection_id: CollectionId, new_sponsor: T::AccountId) -> DispatchResult {1066 let sender = ensure_signed(origin)?;1067 let mut target_collection = Self::get_collection(collection_id)?;1068 Self::check_owner_permissions(&target_collection, &sender)?;10691070 target_collection.sponsorship = SponsorshipState::Unconfirmed(new_sponsor);1071 Self::save_collection(target_collection);10721073 Ok(())1074 }10751076 /// # Permissions1077 /// 1078 /// * Sponsor.1079 /// 1080 /// # Arguments1081 /// 1082 /// * collection_id.1083 #[weight = <T as Config>::WeightInfo::confirm_sponsorship()]1084 #[transactional]1085 pub fn confirm_sponsorship(origin, collection_id: CollectionId) -> DispatchResult {1086 let sender = ensure_signed(origin)?;10871088 let mut target_collection = Self::get_collection(collection_id)?;1089 ensure!(1090 target_collection.sponsorship.pending_sponsor() == Some(&sender),1091 Error::<T>::ConfirmUnsetSponsorFail1092 );10931094 target_collection.sponsorship = SponsorshipState::Confirmed(sender);1095 Self::save_collection(target_collection);10961097 Ok(())1098 }10991100 /// Switch back to pay-per-own-transaction model.1101 ///1102 /// # Permissions1103 ///1104 /// * Collection owner.1105 /// 1106 /// # Arguments1107 /// 1108 /// * collection_id.1109 #[weight = <T as Config>::WeightInfo::remove_collection_sponsor()]1110 #[transactional]1111 pub fn remove_collection_sponsor(origin, collection_id: CollectionId) -> DispatchResult {1112 let sender = ensure_signed(origin)?;11131114 let mut target_collection = Self::get_collection(collection_id)?;1115 Self::check_owner_permissions(&target_collection, &sender)?;11161117 target_collection.sponsorship = SponsorshipState::Disabled;1118 Self::save_collection(target_collection);11191120 Ok(())1121 }11221123 /// This method creates a concrete instance of NFT Collection created with CreateCollection method.1124 /// 1125 /// # Permissions1126 /// 1127 /// * Collection Owner.1128 /// * Collection Admin.1129 /// * Anyone if1130 /// * White List is enabled, and1131 /// * Address is added to white list, and1132 /// * MintPermission is enabled (see SetMintPermission method)1133 /// 1134 /// # Arguments1135 /// 1136 /// * collection_id: ID of the collection.1137 /// 1138 /// * owner: Address, initial owner of the NFT.1139 ///1140 /// * data: Token data to store on chain.1141 // #[weight =1142 // (130_000_000 as Weight)1143 // .saturating_add((2135 as Weight).saturating_mul((properties.len() as u64) as Weight))1144 // .saturating_add(RocksDbWeight::get().reads(10 as Weight))1145 // .saturating_add(RocksDbWeight::get().writes(8 as Weight))]11461147 #[weight = <T as Config>::WeightInfo::create_item(data.len())]1148 #[transactional]1149 pub fn create_item(origin, collection_id: CollectionId, owner: T::CrossAccountId, data: CreateItemData) -> DispatchResult {1150 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1151 let collection = Self::get_collection(collection_id)?;11521153 Self::create_item_internal(&sender, &collection, &owner, data)?;11541155 Self::submit_logs(collection)?;1156 Ok(())1157 }11581159 /// This method creates multiple items in a collection created with CreateCollection method.1160 /// 1161 /// # Permissions1162 /// 1163 /// * Collection Owner.1164 /// * Collection Admin.1165 /// * Anyone if1166 /// * White List is enabled, and1167 /// * Address is added to white list, and1168 /// * MintPermission is enabled (see SetMintPermission method)1169 /// 1170 /// # Arguments1171 /// 1172 /// * collection_id: ID of the collection.1173 /// 1174 /// * itemsData: Array items properties. Each property is an array of bytes itself, see [create_item].1175 /// 1176 /// * owner: Address, initial owner of the NFT.1177 #[weight = <T as Config>::WeightInfo::create_item(items_data.into_iter()1178 .map(|data| { data.len() })1179 .sum())]1180 #[transactional]1181 pub fn create_multiple_items(origin, collection_id: CollectionId, owner: T::CrossAccountId, items_data: Vec<CreateItemData>) -> DispatchResult {11821183 ensure!(items_data.len() > 0, Error::<T>::EmptyArgument);1184 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1185 let collection = Self::get_collection(collection_id)?;11861187 Self::create_multiple_items_internal(&sender, &collection, &owner, items_data)?;11881189 Self::submit_logs(collection)?;1190 Ok(())1191 }11921193 /// Destroys a concrete instance of NFT.1194 /// 1195 /// # Permissions1196 /// 1197 /// * Collection Owner.1198 /// * Collection Admin.1199 /// * Current NFT Owner.1200 /// 1201 /// # Arguments1202 /// 1203 /// * collection_id: ID of the collection.1204 /// 1205 /// * item_id: ID of NFT to burn.1206 #[weight = <T as Config>::WeightInfo::burn_item()]1207 #[transactional]1208 pub fn burn_item(origin, collection_id: CollectionId, item_id: TokenId, value: u128) -> DispatchResult {12091210 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1211 let target_collection = Self::get_collection(collection_id)?;12121213 Self::burn_item_internal(&sender, &target_collection, item_id, value)?;12141215 Self::submit_logs(target_collection)?;1216 Ok(())1217 }12181219 /// Change ownership of the token.1220 /// 1221 /// # Permissions1222 /// 1223 /// * Collection Owner1224 /// * Collection Admin1225 /// * Current NFT owner1226 ///1227 /// # Arguments1228 /// 1229 /// * recipient: Address of token recipient.1230 /// 1231 /// * collection_id.1232 /// 1233 /// * item_id: ID of the item1234 /// * Non-Fungible Mode: Required.1235 /// * Fungible Mode: Ignored.1236 /// * Re-Fungible Mode: Required.1237 /// 1238 /// * value: Amount to transfer.1239 /// * Non-Fungible Mode: Ignored1240 /// * Fungible Mode: Must specify transferred amount1241 /// * Re-Fungible Mode: Must specify transferred portion (between 0 and 1)1242 #[weight = <T as Config>::WeightInfo::transfer()]1243 #[transactional]1244 pub fn transfer(origin, recipient: T::CrossAccountId, collection_id: CollectionId, item_id: TokenId, value: u128) -> DispatchResult {1245 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1246 let collection = Self::get_collection(collection_id)?;12471248 Self::transfer_internal(&sender, &recipient, &collection, item_id, value)?;12491250 Self::submit_logs(collection)?;1251 Ok(())1252 }12531254 /// Set, change, or remove approved address to transfer the ownership of the NFT.1255 /// 1256 /// # Permissions1257 /// 1258 /// * Collection Owner1259 /// * Collection Admin1260 /// * Current NFT owner1261 /// 1262 /// # Arguments1263 /// 1264 /// * approved: Address that is approved to transfer this NFT or zero (if needed to remove approval).1265 /// 1266 /// * collection_id.1267 /// 1268 /// * item_id: ID of the item.1269 #[weight = <T as Config>::WeightInfo::approve()]1270 #[transactional]1271 pub fn approve(origin, spender: T::CrossAccountId, collection_id: CollectionId, item_id: TokenId, amount: u128) -> DispatchResult {1272 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1273 let collection = Self::get_collection(collection_id)?;12741275 Self::approve_internal(&sender, &spender, &collection, item_id, amount)?;12761277 Self::submit_logs(collection)?;1278 Ok(())1279 }1280 1281 /// 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.1282 /// 1283 /// # Permissions1284 /// * Collection Owner1285 /// * Collection Admin1286 /// * Current NFT owner1287 /// * Address approved by current NFT owner1288 /// 1289 /// # Arguments1290 /// 1291 /// * from: Address that owns token.1292 /// 1293 /// * recipient: Address of token recipient.1294 /// 1295 /// * collection_id.1296 /// 1297 /// * item_id: ID of the item.1298 /// 1299 /// * value: Amount to transfer.1300 #[weight = <T as Config>::WeightInfo::transfer_from()]1301 #[transactional]1302 pub fn transfer_from(origin, from: T::CrossAccountId, recipient: T::CrossAccountId, collection_id: CollectionId, item_id: TokenId, value: u128 ) -> DispatchResult {1303 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1304 let collection = Self::get_collection(collection_id)?;13051306 Self::transfer_from_internal(&sender, &from, &recipient, &collection, item_id, value)?;13071308 Self::submit_logs(collection)?;1309 Ok(())1310 }1311 // #[weight = 0]1312 // // let no_perm_mes = "You do not have permissions to modify this collection";1313 // // ensure!(<ApprovedList<T>>::contains_key((collection_id, item_id)), no_perm_mes);1314 // // let list_itm = <ApprovedList<T>>::get((collection_id, item_id));1315 // // ensure!(list_itm.contains(&new_owner.clone()), no_perm_mes);13161317 // // // on_nft_received call13181319 // // Self::transfer(origin, collection_id, item_id, new_owner)?;13201321 // Ok(())1322 // }13231324 /// Set off-chain data schema.1325 /// 1326 /// # Permissions1327 /// 1328 /// * Collection Owner1329 /// * Collection Admin1330 /// 1331 /// # Arguments1332 /// 1333 /// * collection_id.1334 /// 1335 /// * schema: String representing the offchain data schema.1336 #[weight = <T as Config>::WeightInfo::set_variable_meta_data()]1337 #[transactional]1338 pub fn set_variable_meta_data (1339 origin,1340 collection_id: CollectionId,1341 item_id: TokenId,1342 data: Vec<u8>1343 ) -> DispatchResult {1344 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1345 1346 let collection = Self::get_collection(collection_id)?;13471348 Self::set_variable_meta_data_internal(&sender, &collection, item_id, data)?;13491350 Ok(())1351 }1352 1353 /// Set schema standard1354 /// ImageURL1355 /// Unique1356 /// 1357 /// # Permissions1358 /// 1359 /// * Collection Owner1360 /// * Collection Admin1361 /// 1362 /// # Arguments1363 /// 1364 /// * collection_id.1365 /// 1366 /// * schema: SchemaVersion: enum1367 #[weight = <T as Config>::WeightInfo::set_schema_version()]1368 #[transactional]1369 pub fn set_schema_version(1370 origin,1371 collection_id: CollectionId,1372 version: SchemaVersion1373 ) -> DispatchResult {1374 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1375 let mut target_collection = Self::get_collection(collection_id)?;1376 Self::check_owner_or_admin_permissions(&target_collection, &sender)?;1377 target_collection.schema_version = version;1378 Self::save_collection(target_collection);13791380 Ok(())1381 }13821383 /// Set off-chain data schema.1384 /// 1385 /// # Permissions1386 /// 1387 /// * Collection Owner1388 /// * Collection Admin1389 /// 1390 /// # Arguments1391 /// 1392 /// * collection_id.1393 /// 1394 /// * schema: String representing the offchain data schema.1395 #[weight = <T as Config>::WeightInfo::set_offchain_schema()]1396 #[transactional]1397 pub fn set_offchain_schema(1398 origin,1399 collection_id: CollectionId,1400 schema: Vec<u8>1401 ) -> DispatchResult {1402 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1403 let mut target_collection = Self::get_collection(collection_id)?;1404 Self::check_owner_or_admin_permissions(&target_collection, &sender)?;14051406 // check schema limit1407 ensure!(schema.len() as u32 <= ChainLimit::get().offchain_schema_limit, "");14081409 target_collection.offchain_schema = schema;1410 Self::save_collection(target_collection);14111412 Ok(())1413 }14141415 /// Set const on-chain data schema.1416 /// 1417 /// # Permissions1418 /// 1419 /// * Collection Owner1420 /// * Collection Admin1421 /// 1422 /// # Arguments1423 /// 1424 /// * collection_id.1425 /// 1426 /// * schema: String representing the const on-chain data schema.1427 #[weight = <T as Config>::WeightInfo::set_const_on_chain_schema()]1428 #[transactional]1429 pub fn set_const_on_chain_schema (1430 origin,1431 collection_id: CollectionId,1432 schema: Vec<u8>1433 ) -> DispatchResult {1434 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1435 let mut target_collection = Self::get_collection(collection_id)?;1436 Self::check_owner_or_admin_permissions(&target_collection, &sender)?;14371438 // check schema limit1439 ensure!(schema.len() as u32 <= ChainLimit::get().const_on_chain_schema_limit, "");14401441 target_collection.const_on_chain_schema = schema;1442 Self::save_collection(target_collection);14431444 Ok(())1445 }14461447 /// Set variable on-chain data schema.1448 /// 1449 /// # Permissions1450 /// 1451 /// * Collection Owner1452 /// * Collection Admin1453 /// 1454 /// # Arguments1455 /// 1456 /// * collection_id.1457 /// 1458 /// * schema: String representing the variable on-chain data schema.1459 #[weight = <T as Config>::WeightInfo::set_const_on_chain_schema()]1460 #[transactional]1461 pub fn set_variable_on_chain_schema (1462 origin,1463 collection_id: CollectionId,1464 schema: Vec<u8>1465 ) -> DispatchResult {1466 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1467 let mut target_collection = Self::get_collection(collection_id)?;1468 Self::check_owner_or_admin_permissions(&target_collection, &sender)?;14691470 // check schema limit1471 ensure!(schema.len() as u32 <= ChainLimit::get().variable_on_chain_schema_limit, "");14721473 target_collection.variable_on_chain_schema = schema;1474 Self::save_collection(target_collection);14751476 Ok(())1477 }14781479 // Sudo permissions function1480 #[weight = <T as Config>::WeightInfo::set_chain_limits()]1481 #[transactional]1482 pub fn set_chain_limits(1483 origin,1484 limits: ChainLimits1485 ) -> DispatchResult {14861487 #[cfg(not(feature = "runtime-benchmarks"))]1488 ensure_root(origin)?;14891490 <ChainLimit>::put(limits);1491 Ok(())1492 }14931494 /// Enable smart contract self-sponsoring.1495 /// 1496 /// # Permissions1497 /// 1498 /// * Contract Owner1499 /// 1500 /// # Arguments1501 /// 1502 /// * contract address1503 /// * enable flag1504 /// 1505 #[weight = <T as Config>::WeightInfo::enable_contract_sponsoring()]1506 #[transactional]1507 pub fn enable_contract_sponsoring(1508 origin,1509 contract_address: T::AccountId,1510 enable: bool1511 ) -> DispatchResult {15121513 let sender = ensure_signed(origin)?;15141515 #[cfg(feature = "runtime-benchmarks")]1516 <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());15171518 Self::ensure_contract_owned(sender, &contract_address)?;15191520 <ContractSelfSponsoring<T>>::insert(contract_address, enable);1521 Ok(())1522 }15231524 /// Set the rate limit for contract sponsoring to specified number of blocks.1525 /// 1526 /// If not set (has the default value of 0 blocks), the sponsoring will be disabled. 1527 /// If set to the number B (for blocks), the transactions will be sponsored with a rate 1528 /// limit of B, i.e. fees for every transaction sent to this smart contract will be paid 1529 /// from contract endowment if there are at least B blocks between such transactions. 1530 /// Nonetheless, if transactions are sent more frequently, the fees are paid by the sender.1531 /// 1532 /// # Permissions1533 /// 1534 /// * Contract Owner1535 /// 1536 /// # Arguments1537 /// 1538 /// -`contract_address`: Address of the contract to sponsor1539 /// -`rate_limit`: Number of blocks to wait until the next sponsored transaction is allowed1540 /// 1541 #[weight = <T as Config>::WeightInfo::set_contract_sponsoring_rate_limit()]1542 #[transactional]1543 pub fn set_contract_sponsoring_rate_limit(1544 origin,1545 contract_address: T::AccountId,1546 rate_limit: T::BlockNumber1547 ) -> DispatchResult {1548 let sender = ensure_signed(origin)?;15491550 #[cfg(feature = "runtime-benchmarks")]1551 <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());15521553 Self::ensure_contract_owned(sender, &contract_address)?;1554 <ContractSponsoringRateLimit<T>>::insert(contract_address, rate_limit);1555 Ok(())1556 }15571558 /// Enable the white list for a contract. Only addresses added to the white list with addToContractWhiteList will be able to call this smart contract.1559 /// 1560 /// # Permissions1561 /// 1562 /// * Address that deployed smart contract.1563 /// 1564 /// # Arguments1565 /// 1566 /// -`contract_address`: Address of the contract.1567 /// 1568 /// - `enable`: . 1569 #[weight = <T as Config>::WeightInfo::toggle_contract_white_list()]1570 #[transactional]1571 pub fn toggle_contract_white_list(1572 origin,1573 contract_address: T::AccountId,1574 enable: bool1575 ) -> DispatchResult {1576 let sender = ensure_signed(origin)?;15771578 #[cfg(feature = "runtime-benchmarks")]1579 <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());15801581 Self::ensure_contract_owned(sender, &contract_address)?;1582 if enable {1583 <ContractWhiteListEnabled<T>>::insert(contract_address, true);1584 } else {1585 <ContractWhiteListEnabled<T>>::remove(contract_address);1586 }1587 Ok(())1588 }1589 1590 /// Add an address to smart contract white list.1591 /// 1592 /// # Permissions1593 /// 1594 /// * Address that deployed smart contract.1595 /// 1596 /// # Arguments1597 /// 1598 /// -`contract_address`: Address of the contract.1599 ///1600 /// -`account_address`: Address to add.1601 #[weight = <T as Config>::WeightInfo::add_to_contract_white_list()]1602 #[transactional]1603 pub fn add_to_contract_white_list(1604 origin,1605 contract_address: T::AccountId,1606 account_address: T::AccountId1607 ) -> DispatchResult {1608 let sender = ensure_signed(origin)?;16091610 #[cfg(feature = "runtime-benchmarks")]1611 <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());1612 1613 Self::ensure_contract_owned(sender, &contract_address)?; 1614 <ContractWhiteList<T>>::insert(contract_address, account_address, true);1615 Ok(())1616 }16171618 /// Remove an address from smart contract white list.1619 /// 1620 /// # Permissions1621 /// 1622 /// * Address that deployed smart contract.1623 /// 1624 /// # Arguments1625 /// 1626 /// -`contract_address`: Address of the contract.1627 ///1628 /// -`account_address`: Address to remove.1629 #[weight = <T as Config>::WeightInfo::remove_from_contract_white_list()]1630 #[transactional]1631 pub fn remove_from_contract_white_list(1632 origin,1633 contract_address: T::AccountId,1634 account_address: T::AccountId1635 ) -> DispatchResult {1636 let sender = ensure_signed(origin)?;16371638 #[cfg(feature = "runtime-benchmarks")]1639 <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());16401641 Self::ensure_contract_owned(sender, &contract_address)?;1642 <ContractWhiteList<T>>::remove(contract_address, account_address);1643 Ok(())1644 }16451646 #[weight = <T as Config>::WeightInfo::set_collection_limits()]1647 #[transactional]1648 pub fn set_collection_limits(1649 origin,1650 collection_id: u32,1651 new_limits: CollectionLimits<T::BlockNumber>,1652 ) -> DispatchResult {1653 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1654 let mut target_collection = Self::get_collection(collection_id)?;1655 Self::check_owner_permissions(&target_collection, &sender.as_sub())?;1656 let old_limits = &target_collection.limits;1657 let chain_limits = ChainLimit::get();16581659 // collection bounds1660 ensure!(new_limits.sponsor_transfer_timeout <= MAX_SPONSOR_TIMEOUT &&1661 new_limits.account_token_ownership_limit <= MAX_TOKEN_OWNERSHIP && 1662 new_limits.sponsored_data_size <= chain_limits.custom_data_limit,1663 Error::<T>::CollectionLimitBoundsExceeded);16641665 // token_limit check prev1666 ensure!(old_limits.token_limit >= new_limits.token_limit, Error::<T>::CollectionTokenLimitExceeded);1667 ensure!(new_limits.token_limit > 0, Error::<T>::CollectionTokenLimitExceeded);16681669 ensure!(1670 (old_limits.owner_can_transfer || !new_limits.owner_can_transfer) &&1671 (old_limits.owner_can_destroy || !new_limits.owner_can_destroy),1672 Error::<T>::OwnerPermissionsCantBeReverted,1673 );16741675 target_collection.limits = new_limits;1676 Self::save_collection(target_collection);16771678 Ok(())1679 } 1680 }1681}16821683impl<T: Config> Module<T> {1684 pub fn create_item_internal(sender: &T::CrossAccountId, collection: &CollectionHandle<T>, owner: &T::CrossAccountId, data: CreateItemData) -> DispatchResult {1685 Self::can_create_items_in_collection(&collection, &sender, &owner, 1)?;1686 Self::validate_create_item_args(&collection, &data)?;1687 Self::create_item_no_validation(&collection, owner, data)?;16881689 Ok(())1690 }16911692 pub fn transfer_internal(sender: &T::CrossAccountId, recipient: &T::CrossAccountId, target_collection: &CollectionHandle<T>, item_id: TokenId, value: u128) -> DispatchResult {1693 // Limits check1694 Self::is_correct_transfer(target_collection, &recipient)?;16951696 // Transfer permissions check1697 ensure!(Self::is_item_owner(&sender, target_collection, item_id) ||1698 Self::is_owner_or_admin_permissions(target_collection, &sender),1699 Error::<T>::NoPermission);17001701 if target_collection.access == AccessMode::WhiteList {1702 Self::check_white_list(target_collection, &sender)?;1703 Self::check_white_list(target_collection, &recipient)?;1704 }17051706 match target_collection.mode1707 {1708 CollectionMode::NFT => Self::transfer_nft(target_collection, item_id, sender.clone(), recipient.clone())?,1709 CollectionMode::Fungible(_) => Self::transfer_fungible(target_collection, value, &sender, &recipient)?,1710 CollectionMode::ReFungible => Self::transfer_refungible(target_collection, item_id, value, sender.clone(), recipient.clone())?,1711 _ => ()1712 };17131714 Self::deposit_event(RawEvent::Transfer(target_collection.id, item_id, sender.clone(), recipient.clone(), value));17151716 Ok(())1717 }17181719 pub fn approve_internal(1720 sender: &T::CrossAccountId,1721 spender: &T::CrossAccountId,1722 collection: &CollectionHandle<T>,1723 item_id: TokenId,1724 amount: u1281725 ) -> DispatchResult {1726 Self::token_exists(&collection, item_id)?;17271728 // Transfer permissions check1729 let bypasses_limits = collection.limits.owner_can_transfer &&1730 Self::is_owner_or_admin_permissions(1731 &collection,1732 &sender,1733 );17341735 let allowance_limit = if bypasses_limits {1736 None1737 } else if let Some(amount) = Self::owned_amount(1738 &sender,1739 &collection,1740 item_id,1741 ) {1742 Some(amount)1743 } else {1744 fail!(Error::<T>::NoPermission);1745 };17461747 if collection.access == AccessMode::WhiteList {1748 Self::check_white_list(&collection, &sender)?;1749 Self::check_white_list(&collection, &spender)?;1750 }17511752 let allowance: u128 = amount1753 .checked_add(<Allowances<T>>::get(collection.id, (item_id, sender.as_sub(), spender.as_sub())))1754 .ok_or(Error::<T>::NumOverflow)?;1755 if let Some(limit) = allowance_limit {1756 ensure!(limit >= allowance, Error::<T>::TokenValueTooLow);1757 }1758 <Allowances<T>>::insert(collection.id, (item_id, sender.as_sub(), spender.as_sub()), allowance);17591760 if matches!(collection.mode, CollectionMode::NFT) {1761 // TODO: NFT: only one owner may exist for token in ERC7211762 collection.log(ERC721Events::Approval {1763 owner: *sender.as_eth(),1764 approved: *spender.as_eth(),1765 token_id: item_id.into(),1766 });1767 }17681769 if matches!(collection.mode, CollectionMode::Fungible(_)) {1770 // TODO: NFT: only one owner may exist for token in ERC201771 collection.log(ERC20Events::Approval {1772 owner: *sender.as_eth(),1773 spender: *spender.as_eth(),1774 value: allowance.into()1775 });1776 }17771778 Self::deposit_event(RawEvent::Approved(collection.id, item_id, sender.clone(), spender.clone(), allowance));1779 Ok(())1780 }17811782 pub fn transfer_from_internal(1783 sender: &T::CrossAccountId,1784 from: &T::CrossAccountId,1785 recipient: &T::CrossAccountId,1786 collection: &CollectionHandle<T>,1787 item_id: TokenId,1788 amount: u128,1789 ) -> DispatchResult {1790 // Check approval1791 let approval: u128 = <Allowances<T>>::get(collection.id, (item_id, from.as_sub(), sender.as_sub()));17921793 // Limits check1794 Self::is_correct_transfer(&collection, &recipient)?;17951796 // Transfer permissions check1797 ensure!(1798 approval >= amount || 1799 (1800 collection.limits.owner_can_transfer &&1801 Self::is_owner_or_admin_permissions(&collection, &sender)1802 ),1803 Error::<T>::NoPermission1804 );18051806 if collection.access == AccessMode::WhiteList {1807 Self::check_white_list(&collection, &sender)?;1808 Self::check_white_list(&collection, &recipient)?;1809 }18101811 // Reduce approval by transferred amount or remove if remaining approval drops to 01812 let allowance = approval.saturating_sub(amount);1813 if allowance > 0 {1814 <Allowances<T>>::insert(collection.id, (item_id, from.as_sub(), sender.as_sub()), allowance);1815 } else {1816 <Allowances<T>>::remove(collection.id, (item_id, from.as_sub(), sender.as_sub()));1817 }18181819 match collection.mode {1820 CollectionMode::NFT => {1821 Self::transfer_nft(&collection, item_id, from.clone(), recipient.clone())?1822 }1823 CollectionMode::Fungible(_) => {1824 Self::transfer_fungible(&collection, amount, &from, &recipient)?1825 }1826 CollectionMode::ReFungible => {1827 Self::transfer_refungible(&collection, item_id, amount, from.clone(), recipient.clone())?1828 }1829 _ => ()1830 };18311832 if matches!(collection.mode, CollectionMode::Fungible(_)) {1833 collection.log(ERC20Events::Approval {1834 owner: *from.as_eth(),1835 spender: *sender.as_eth(),1836 value: allowance.into()1837 });1838 }18391840 Ok(())1841 }18421843 pub fn set_variable_meta_data_internal(1844 sender: &T::CrossAccountId,1845 collection: &CollectionHandle<T>, 1846 item_id: TokenId,1847 data: Vec<u8>,1848 ) -> DispatchResult {1849 Self::token_exists(&collection, item_id)?;18501851 ensure!(ChainLimit::get().custom_data_limit >= data.len() as u32, Error::<T>::TokenVariableDataLimitExceeded);18521853 // Modify permissions check1854 ensure!(Self::is_item_owner(&sender, &collection, item_id) ||1855 Self::is_owner_or_admin_permissions(&collection, &sender),1856 Error::<T>::NoPermission);18571858 match collection.mode1859 {1860 CollectionMode::NFT => Self::set_nft_variable_data(&collection, item_id, data)?,1861 CollectionMode::ReFungible => Self::set_re_fungible_variable_data(&collection, item_id, data)?,1862 CollectionMode::Fungible(_) => fail!(Error::<T>::CantStoreMetadataInFungibleTokens),1863 _ => fail!(Error::<T>::UnexpectedCollectionType)1864 };18651866 Ok(())1867 }18681869 pub fn create_multiple_items_internal(1870 sender: &T::CrossAccountId,1871 collection: &CollectionHandle<T>,1872 owner: &T::CrossAccountId,1873 items_data: Vec<CreateItemData>,1874 ) -> DispatchResult {1875 Self::can_create_items_in_collection(&collection, &sender, &owner, items_data.len() as u32)?;18761877 for data in &items_data {1878 Self::validate_create_item_args(&collection, data)?;1879 }1880 for data in &items_data {1881 Self::create_item_no_validation(&collection, owner, data.clone())?;1882 }18831884 Ok(())1885 }18861887 pub fn burn_item_internal(1888 sender: &T::CrossAccountId,1889 collection: &CollectionHandle<T>,1890 item_id: TokenId,1891 value: u128,1892 ) -> DispatchResult {1893 ensure!(1894 Self::is_item_owner(&sender, &collection, item_id) ||1895 (1896 collection.limits.owner_can_transfer &&1897 Self::is_owner_or_admin_permissions(&collection, &sender)1898 ),1899 Error::<T>::NoPermission1900 );19011902 if collection.access == AccessMode::WhiteList {1903 Self::check_white_list(&collection, &sender)?;1904 }19051906 match collection.mode1907 {1908 CollectionMode::NFT => Self::burn_nft_item(&collection, item_id)?,1909 CollectionMode::Fungible(_) => Self::burn_fungible_item(&sender, &collection, value)?,1910 CollectionMode::ReFungible => Self::burn_refungible_item(&collection, item_id, &sender)?,1911 _ => ()1912 };19131914 Ok(())1915 }19161917 pub fn toggle_white_list_internal(1918 sender: &T::CrossAccountId,1919 collection: &CollectionHandle<T>,1920 address: &T::CrossAccountId,1921 whitelisted: bool,1922 ) -> DispatchResult {1923 Self::check_owner_or_admin_permissions(&collection, &sender)?;19241925 if whitelisted {1926 <WhiteList<T>>::insert(collection.id, address.as_sub(), true);1927 } else {1928 <WhiteList<T>>::remove(collection.id, address.as_sub());1929 }19301931 Ok(())1932 }19331934 fn is_correct_transfer(collection: &CollectionHandle<T>, recipient: &T::CrossAccountId) -> DispatchResult {1935 let collection_id = collection.id;19361937 // check token limit and account token limit1938 let account_items: u32 = <AddressTokens<T>>::get(collection_id, recipient.as_sub()).len() as u32;1939 ensure!(collection.limits.account_token_ownership_limit > account_items, Error::<T>::AccountTokenLimitExceeded);1940 1941 Ok(())1942 }19431944 fn can_create_items_in_collection(collection: &CollectionHandle<T>, sender: &T::CrossAccountId, owner: &T::CrossAccountId, amount: u32) -> DispatchResult {1945 let collection_id = collection.id;19461947 // check token limit and account token limit1948 let total_items: u32 = ItemListIndex::get(collection_id)1949 .checked_add(amount)1950 .ok_or(Error::<T>::CollectionTokenLimitExceeded)?;1951 let account_items: u32 = (<AddressTokens<T>>::get(collection_id, owner.as_sub()).len() as u32)1952 .checked_add(amount)1953 .ok_or(Error::<T>::AccountTokenLimitExceeded)?;1954 ensure!(collection.limits.token_limit >= total_items, Error::<T>::CollectionTokenLimitExceeded);1955 ensure!(collection.limits.account_token_ownership_limit >= account_items, Error::<T>::AccountTokenLimitExceeded);19561957 if !Self::is_owner_or_admin_permissions(collection, &sender) {1958 ensure!(collection.mint_mode == true, Error::<T>::PublicMintingNotAllowed);1959 Self::check_white_list(collection, owner)?;1960 Self::check_white_list(collection, sender)?;1961 }19621963 Ok(())1964 }19651966 fn validate_create_item_args(target_collection: &CollectionHandle<T>, data: &CreateItemData) -> DispatchResult {1967 match target_collection.mode1968 {1969 CollectionMode::NFT => {1970 if let CreateItemData::NFT(data) = data {1971 // check sizes1972 ensure!(ChainLimit::get().custom_data_limit >= data.const_data.len() as u32, Error::<T>::TokenConstDataLimitExceeded);1973 ensure!(ChainLimit::get().custom_data_limit >= data.variable_data.len() as u32, Error::<T>::TokenVariableDataLimitExceeded);1974 } else {1975 fail!(Error::<T>::NotNftDataUsedToMintNftCollectionToken);1976 }1977 },1978 CollectionMode::Fungible(_) => {1979 if let CreateItemData::Fungible(_) = data {1980 } else {1981 fail!(Error::<T>::NotFungibleDataUsedToMintFungibleCollectionToken);1982 }1983 },1984 CollectionMode::ReFungible => {1985 if let CreateItemData::ReFungible(data) = data {19861987 // check sizes1988 ensure!(ChainLimit::get().custom_data_limit >= data.const_data.len() as u32, Error::<T>::TokenConstDataLimitExceeded);1989 ensure!(ChainLimit::get().custom_data_limit >= data.variable_data.len() as u32, Error::<T>::TokenVariableDataLimitExceeded);19901991 // Check refungibility limits1992 ensure!(data.pieces <= MAX_REFUNGIBLE_PIECES, Error::<T>::WrongRefungiblePieces);1993 ensure!(data.pieces > 0, Error::<T>::WrongRefungiblePieces);1994 } else {1995 fail!(Error::<T>::NotReFungibleDataUsedToMintReFungibleCollectionToken);1996 }1997 },1998 _ => { fail!(Error::<T>::UnexpectedCollectionType); }1999 };20002001 Ok(())2002 }20032004 fn create_item_no_validation(collection: &CollectionHandle<T>, owner: &T::CrossAccountId, data: CreateItemData) -> DispatchResult {2005 match data2006 {2007 CreateItemData::NFT(data) => {2008 let item = NftItemType {2009 owner: owner.clone(),2010 const_data: data.const_data,2011 variable_data: data.variable_data2012 };20132014 Self::add_nft_item(collection, item)?;2015 },2016 CreateItemData::Fungible(data) => {2017 Self::add_fungible_item(collection, &owner, data.value)?;2018 },2019 CreateItemData::ReFungible(data) => {2020 let mut owner_list = Vec::new();2021 owner_list.push(Ownership {owner: owner.clone(), fraction: data.pieces});20222023 let item = ReFungibleItemType {2024 owner: owner_list,2025 const_data: data.const_data,2026 variable_data: data.variable_data2027 };20282029 Self::add_refungible_item(collection, item)?;2030 }2031 };20322033 Ok(())2034 }20352036 fn add_fungible_item(collection: &CollectionHandle<T>, owner: &T::CrossAccountId, value: u128) -> DispatchResult {2037 let collection_id = collection.id;20382039 // Does new owner already have an account?2040 let balance: u128 = <FungibleItemList<T>>::get(collection_id, owner.as_sub()).value;20412042 // Mint 2043 let item = FungibleItemType {2044 value: balance.checked_add(value).ok_or(Error::<T>::NumOverflow)?,2045 };2046 <FungibleItemList<T>>::insert(collection_id, owner.as_sub(), item);20472048 // Update balance2049 let new_balance = <Balance<T>>::get(collection_id, owner.as_sub())2050 .checked_add(value)2051 .ok_or(Error::<T>::NumOverflow)?;2052 <Balance<T>>::insert(collection_id, owner.as_sub(), new_balance);20532054 Self::deposit_event(RawEvent::ItemCreated(collection_id, 0, owner.clone()));2055 Ok(())2056 }20572058 fn add_refungible_item(collection: &CollectionHandle<T>, item: ReFungibleItemType<T::CrossAccountId>) -> DispatchResult {2059 let collection_id = collection.id;20602061 let current_index = <ItemListIndex>::get(collection_id)2062 .checked_add(1)2063 .ok_or(Error::<T>::NumOverflow)?;2064 let itemcopy = item.clone();20652066 ensure!(2067 item.owner.len() == 1,2068 Error::<T>::BadCreateRefungibleCall,2069 );2070 let item_owner = item.owner.first().expect("only one owner is defined");20712072 let value = item_owner.fraction;2073 let owner = item_owner.owner.clone();20742075 Self::add_token_index(collection_id, current_index, &owner)?;20762077 <ItemListIndex>::insert(collection_id, current_index);2078 <ReFungibleItemList<T>>::insert(collection_id, current_index, itemcopy);20792080 // Update balance2081 let new_balance = <Balance<T>>::get(collection_id, owner.as_sub())2082 .checked_add(value)2083 .ok_or(Error::<T>::NumOverflow)?;2084 <Balance<T>>::insert(collection_id, owner.as_sub(), new_balance);20852086 Self::deposit_event(RawEvent::ItemCreated(collection_id, current_index, owner));2087 Ok(())2088 }20892090 fn add_nft_item(collection: &CollectionHandle<T>, item: NftItemType<T::CrossAccountId>) -> DispatchResult {2091 let collection_id = collection.id;20922093 let current_index = <ItemListIndex>::get(collection_id)2094 .checked_add(1)2095 .ok_or(Error::<T>::NumOverflow)?;20962097 let item_owner = item.owner.clone();2098 Self::add_token_index(collection_id, current_index, &item.owner)?;20992100 <ItemListIndex>::insert(collection_id, current_index);2101 <NftItemList<T>>::insert(collection_id, current_index, item);21022103 // Update balance2104 let new_balance = <Balance<T>>::get(collection_id, item_owner.as_sub())2105 .checked_add(1)2106 .ok_or(Error::<T>::NumOverflow)?;2107 <Balance<T>>::insert(collection_id, item_owner.as_sub(), new_balance);21082109 collection.log(ERC721Events::Transfer {2110 from: H160::default(),2111 to: *item_owner.as_eth(),2112 token_id: current_index.into(),2113 });2114 Self::deposit_event(RawEvent::ItemCreated(collection_id, current_index, item_owner));2115 Ok(())2116 }21172118 fn burn_refungible_item(2119 collection: &CollectionHandle<T>,2120 item_id: TokenId,2121 owner: &T::CrossAccountId,2122 ) -> DispatchResult {2123 let collection_id = collection.id;21242125 let mut token = <ReFungibleItemList<T>>::get(collection_id, item_id)2126 .ok_or(Error::<T>::TokenNotFound)?;2127 let rft_balance = token2128 .owner2129 .iter()2130 .find(|&i| i.owner == *owner)2131 .ok_or(Error::<T>::TokenNotFound)?;2132 Self::remove_token_index(collection_id, item_id, owner)?;21332134 // update balance2135 let new_balance = <Balance<T>>::get(collection_id, rft_balance.owner.as_sub())2136 .checked_sub(rft_balance.fraction)2137 .ok_or(Error::<T>::NumOverflow)?;2138 <Balance<T>>::insert(collection_id, rft_balance.owner.as_sub(), new_balance);21392140 // Re-create owners list with sender removed2141 let index = token2142 .owner2143 .iter()2144 .position(|i| i.owner == *owner)2145 .expect("owned item is exists");2146 token.owner.remove(index);2147 let owner_count = token.owner.len();21482149 // Burn the token completely if this was the last (only) owner2150 if owner_count == 0 {2151 <ReFungibleItemList<T>>::remove(collection_id, item_id);2152 <VariableMetaDataBasket<T>>::remove(collection_id, item_id);2153 }2154 else {2155 <ReFungibleItemList<T>>::insert(collection_id, item_id, token);2156 }21572158 Ok(())2159 }21602161 fn burn_nft_item(collection: &CollectionHandle<T>, item_id: TokenId) -> DispatchResult {2162 let collection_id = collection.id;21632164 let item = <NftItemList<T>>::get(collection_id, item_id)2165 .ok_or(Error::<T>::TokenNotFound)?;2166 Self::remove_token_index(collection_id, item_id, &item.owner)?;21672168 // update balance2169 let new_balance = <Balance<T>>::get(collection_id, item.owner.as_sub())2170 .checked_sub(1)2171 .ok_or(Error::<T>::NumOverflow)?;2172 <Balance<T>>::insert(collection_id, item.owner.as_sub(), new_balance);2173 <NftItemList<T>>::remove(collection_id, item_id);2174 <VariableMetaDataBasket<T>>::remove(collection_id, item_id);21752176 Self::deposit_event(RawEvent::ItemDestroyed(collection.id, item_id));2177 Ok(())2178 }21792180 fn burn_fungible_item(owner: &T::CrossAccountId, collection: &CollectionHandle<T>, value: u128) -> DispatchResult {2181 let collection_id = collection.id;21822183 let mut balance = <FungibleItemList<T>>::get(collection_id, owner.as_sub());2184 ensure!(balance.value >= value, Error::<T>::TokenValueNotEnough);21852186 // update balance2187 let new_balance = <Balance<T>>::get(collection_id, owner.as_sub())2188 .checked_sub(value)2189 .ok_or(Error::<T>::NumOverflow)?;2190 <Balance<T>>::insert(collection_id, owner.as_sub(), new_balance);21912192 if balance.value - value > 0 {2193 balance.value -= value;2194 <FungibleItemList<T>>::insert(collection_id, owner.as_sub(), balance);2195 }2196 else {2197 <FungibleItemList<T>>::remove(collection_id, owner.as_sub());2198 }21992200 collection.log(ERC20Events::Transfer {2201 from: *owner.as_eth(),2202 to: H160::default(),2203 value: value.into(),2204 });2205 Ok(())2206 }22072208 pub fn get_collection(collection_id: CollectionId) -> Result<CollectionHandle<T>, sp_runtime::DispatchError> {2209 Ok(<CollectionHandle<T>>::get(collection_id)2210 .ok_or(Error::<T>::CollectionNotFound)?)2211 }22122213 fn save_collection(collection: CollectionHandle<T>) {2214 <CollectionById<T>>::insert(collection.id, collection.into_inner());2215 }22162217 pub fn submit_logs(collection: CollectionHandle<T>) -> DispatchResult {2218 if collection.logs.is_empty() {2219 return Ok(())2220 }2221 T::EthereumTransactionSender::submit_logs_transaction(2222 eth::generate_transaction(collection.id, T::EthereumChainId::get()),2223 collection.logs.retrieve_logs(),2224 )2225 }22262227 fn check_owner_permissions(target_collection: &CollectionHandle<T>, subject: &T::AccountId) -> DispatchResult {2228 ensure!(2229 *subject == target_collection.owner,2230 Error::<T>::NoPermission2231 );22322233 Ok(())2234 }22352236 fn is_owner_or_admin_permissions(collection: &CollectionHandle<T>, subject: &T::CrossAccountId) -> bool {2237 *subject.as_sub() == collection.owner || <AdminList<T>>::get(collection.id).contains(&subject)2238 }22392240 fn check_owner_or_admin_permissions(2241 collection: &CollectionHandle<T>,2242 subject: &T::CrossAccountId,2243 ) -> DispatchResult {2244 ensure!(Self::is_owner_or_admin_permissions(collection, subject), Error::<T>::NoPermission);22452246 Ok(())2247 }22482249 fn owned_amount(2250 subject: &T::CrossAccountId,2251 target_collection: &CollectionHandle<T>,2252 item_id: TokenId,2253 ) -> Option<u128> {2254 let collection_id = target_collection.id;22552256 match target_collection.mode {2257 CollectionMode::NFT => (<NftItemList<T>>::get(collection_id, item_id)?.owner == *subject)2258 .then(|| 1),2259 CollectionMode::Fungible(_) => Some(<FungibleItemList<T>>::get(collection_id, &subject.as_sub())2260 .value),2261 CollectionMode::ReFungible => <ReFungibleItemList<T>>::get(collection_id, item_id)?2262 .owner2263 .iter()2264 .find(|i| i.owner == *subject)2265 .map(|i| i.fraction),2266 CollectionMode::Invalid => None,2267 }2268 }22692270 fn is_item_owner(subject: &T::CrossAccountId, target_collection: &CollectionHandle<T>, item_id: TokenId) -> bool {2271 match target_collection.mode {2272 CollectionMode::Fungible(_) => true,2273 _ => Self::owned_amount(&subject, target_collection, item_id).is_some(),2274 }2275 }22762277 fn check_white_list(collection: &CollectionHandle<T>, address: &T::CrossAccountId) -> DispatchResult {2278 let collection_id = collection.id;22792280 let mes = Error::<T>::AddresNotInWhiteList;2281 ensure!(<WhiteList<T>>::contains_key(collection_id, address.as_sub()), mes);22822283 Ok(())2284 }22852286 /// Check if token exists. In case of Fungible, check if there is an entry for 2287 /// the owner in fungible balances double map2288 fn token_exists(2289 target_collection: &CollectionHandle<T>,2290 item_id: TokenId,2291 ) -> DispatchResult {2292 let collection_id = target_collection.id;2293 let exists = match target_collection.mode2294 {2295 CollectionMode::NFT => <NftItemList<T>>::contains_key(collection_id, item_id),2296 CollectionMode::Fungible(_) => true,2297 CollectionMode::ReFungible => <ReFungibleItemList<T>>::contains_key(collection_id, item_id),2298 _ => false2299 };23002301 ensure!(exists == true, Error::<T>::TokenNotFound);2302 Ok(())2303 }23042305 fn transfer_fungible(2306 collection: &CollectionHandle<T>,2307 value: u128,2308 owner: &T::CrossAccountId,2309 recipient: &T::CrossAccountId,2310 ) -> DispatchResult {2311 let collection_id = collection.id;23122313 let mut balance = <FungibleItemList<T>>::get(collection_id, owner.as_sub());2314 ensure!(balance.value >= value, Error::<T>::TokenValueTooLow);23152316 // Send balance to recipient (updates balanceOf of recipient)2317 Self::add_fungible_item(collection, recipient, value)?;23182319 // update balanceOf of sender2320 <Balance<T>>::insert(collection_id, owner.as_sub(), balance.value - value);23212322 // Reduce or remove sender2323 if balance.value == value {2324 <FungibleItemList<T>>::remove(collection_id, owner.as_sub());2325 }2326 else {2327 balance.value -= value;2328 <FungibleItemList<T>>::insert(collection_id, owner.as_sub(), balance);2329 }23302331 collection.log(ERC20Events::Transfer {2332 from: *owner.as_eth(),2333 to: *recipient.as_eth(),2334 value: value.into(),2335 });2336 Self::deposit_event(RawEvent::Transfer(collection.id, 1, owner.clone(), recipient.clone(), value));23372338 Ok(())2339 }23402341 fn transfer_refungible(2342 collection: &CollectionHandle<T>,2343 item_id: TokenId,2344 value: u128,2345 owner: T::CrossAccountId,2346 new_owner: T::CrossAccountId,2347 ) -> DispatchResult {2348 let collection_id = collection.id;2349 let full_item = <ReFungibleItemList<T>>::get(collection_id, item_id)2350 .ok_or(Error::<T>::TokenNotFound)?;23512352 let item = full_item2353 .owner2354 .iter()2355 .filter(|i| i.owner == owner)2356 .next()2357 .ok_or(Error::<T>::TokenNotFound)?;2358 let amount = item.fraction;23592360 ensure!(amount >= value, Error::<T>::TokenValueTooLow);23612362 // update balance2363 let balance_old_owner = <Balance<T>>::get(collection_id, item.owner.as_sub())2364 .checked_sub(value)2365 .ok_or(Error::<T>::NumOverflow)?;2366 <Balance<T>>::insert(collection_id, item.owner.as_sub(), balance_old_owner);23672368 let balance_new_owner = <Balance<T>>::get(collection_id, new_owner.as_sub())2369 .checked_add(value)2370 .ok_or(Error::<T>::NumOverflow)?;2371 <Balance<T>>::insert(collection_id, new_owner.as_sub(), balance_new_owner);23722373 let old_owner = item.owner.clone();2374 let new_owner_has_account = full_item.owner.iter().any(|i| i.owner == new_owner);23752376 // transfer2377 if amount == value && !new_owner_has_account {2378 // change owner2379 // new owner do not have account2380 let mut new_full_item = full_item.clone();2381 new_full_item2382 .owner2383 .iter_mut()2384 .find(|i| i.owner == owner)2385 .expect("old owner does present in refungible")2386 .owner = new_owner.clone();2387 <ReFungibleItemList<T>>::insert(collection_id, item_id, new_full_item);23882389 // update index collection2390 Self::move_token_index(collection_id, item_id, &old_owner, &new_owner)?;2391 } else {2392 let mut new_full_item = full_item.clone();2393 new_full_item2394 .owner2395 .iter_mut()2396 .find(|i| i.owner == owner)2397 .expect("old owner does present in refungible")2398 .fraction -= value;23992400 // separate amount2401 if new_owner_has_account {2402 // new owner has account2403 new_full_item2404 .owner2405 .iter_mut()2406 .find(|i| i.owner == new_owner)2407 .expect("new owner has account")2408 .fraction += value;2409 } else {2410 // new owner do not have account2411 new_full_item.owner.push(Ownership {2412 owner: new_owner.clone(),2413 fraction: value,2414 });2415 Self::add_token_index(collection_id, item_id, &new_owner)?;2416 }24172418 <ReFungibleItemList<T>>::insert(collection_id, item_id, new_full_item);2419 }24202421 Self::deposit_event(RawEvent::Transfer(collection.id, item_id, owner, new_owner, amount));24222423 Ok(())2424 }24252426 fn transfer_nft(2427 collection: &CollectionHandle<T>,2428 item_id: TokenId,2429 sender: T::CrossAccountId,2430 new_owner: T::CrossAccountId,2431 ) -> DispatchResult {2432 let collection_id = collection.id;2433 let mut item = <NftItemList<T>>::get(collection_id, item_id)2434 .ok_or(Error::<T>::TokenNotFound)?;24352436 ensure!(2437 sender == item.owner,2438 Error::<T>::MustBeTokenOwner2439 );24402441 // update balance2442 let balance_old_owner = <Balance<T>>::get(collection_id, item.owner.as_sub())2443 .checked_sub(1)2444 .ok_or(Error::<T>::NumOverflow)?;2445 <Balance<T>>::insert(collection_id, item.owner.as_sub(), balance_old_owner);24462447 let balance_new_owner = <Balance<T>>::get(collection_id, new_owner.as_sub())2448 .checked_add(1)2449 .ok_or(Error::<T>::NumOverflow)?;2450 <Balance<T>>::insert(collection_id, new_owner.as_sub(), balance_new_owner);24512452 // change owner2453 let old_owner = item.owner.clone();2454 item.owner = new_owner.clone();2455 <NftItemList<T>>::insert(collection_id, item_id, item);24562457 // update index collection2458 Self::move_token_index(collection_id, item_id, &old_owner, &new_owner)?;24592460 collection.log(ERC721Events::Transfer {2461 from: *sender.as_eth(),2462 to: *new_owner.as_eth(),2463 token_id: item_id.into(),2464 });2465 Self::deposit_event(RawEvent::Transfer(collection.id, item_id, sender, new_owner, 1));24662467 Ok(())2468 }2469 2470 fn set_re_fungible_variable_data(2471 collection: &CollectionHandle<T>,2472 item_id: TokenId,2473 data: Vec<u8>2474 ) -> DispatchResult {2475 let collection_id = collection.id;2476 let mut item = <ReFungibleItemList<T>>::get(collection_id, item_id)2477 .ok_or(Error::<T>::TokenNotFound)?;24782479 item.variable_data = data;24802481 <ReFungibleItemList<T>>::insert(collection_id, item_id, item);24822483 Ok(())2484 }24852486 fn set_nft_variable_data(2487 collection: &CollectionHandle<T>,2488 item_id: TokenId,2489 data: Vec<u8>2490 ) -> DispatchResult {2491 let collection_id = collection.id;2492 let mut item = <NftItemList<T>>::get(collection_id, item_id)2493 .ok_or(Error::<T>::TokenNotFound)?;2494 2495 item.variable_data = data;24962497 <NftItemList<T>>::insert(collection_id, item_id, item);2498 2499 Ok(())2500 }25012502 fn init_collection(item: &Collection<T>) {2503 // check params2504 assert!(2505 item.decimal_points <= MAX_DECIMAL_POINTS,2506 "decimal_points parameter must be lower than MAX_DECIMAL_POINTS"2507 );2508 assert!(2509 item.name.len() <= 64,2510 "Collection name can not be longer than 63 char"2511 );2512 assert!(2513 item.name.len() <= 256,2514 "Collection description can not be longer than 255 char"2515 );2516 assert!(2517 item.token_prefix.len() <= 16,2518 "Token prefix can not be longer than 15 char"2519 );25202521 // Generate next collection ID2522 let next_id = CreatedCollectionCount::get()2523 .checked_add(1)2524 .unwrap();25252526 CreatedCollectionCount::put(next_id);2527 }25282529 fn init_nft_token(collection_id: CollectionId, item: &NftItemType<T::CrossAccountId>) {2530 let current_index = <ItemListIndex>::get(collection_id)2531 .checked_add(1)2532 .unwrap();25332534 Self::add_token_index(collection_id, current_index, &item.owner).unwrap();25352536 <ItemListIndex>::insert(collection_id, current_index);25372538 // Update balance2539 let new_balance = <Balance<T>>::get(collection_id, item.owner.as_sub())2540 .checked_add(1)2541 .unwrap();2542 <Balance<T>>::insert(collection_id, item.owner.as_sub(), new_balance);2543 }25442545 fn init_fungible_token(collection_id: CollectionId, owner: &T::CrossAccountId, item: &FungibleItemType) {2546 let current_index = <ItemListIndex>::get(collection_id)2547 .checked_add(1)2548 .unwrap();25492550 Self::add_token_index(collection_id, current_index, owner).unwrap();25512552 <ItemListIndex>::insert(collection_id, current_index);25532554 // Update balance2555 let new_balance = <Balance<T>>::get(collection_id, owner.as_sub())2556 .checked_add(item.value)2557 .unwrap();2558 <Balance<T>>::insert(collection_id, owner.as_sub(), new_balance);2559 }25602561 fn init_refungible_token(collection_id: CollectionId, item: &ReFungibleItemType<T::CrossAccountId>) {2562 let current_index = <ItemListIndex>::get(collection_id)2563 .checked_add(1)2564 .unwrap();25652566 let value = item.owner.first().unwrap().fraction;2567 let owner = item.owner.first().unwrap().owner.clone();25682569 Self::add_token_index(collection_id, current_index, &owner).unwrap();25702571 <ItemListIndex>::insert(collection_id, current_index);25722573 // Update balance2574 let new_balance = <Balance<T>>::get(collection_id, &owner.as_sub())2575 .checked_add(value)2576 .unwrap();2577 <Balance<T>>::insert(collection_id, owner.as_sub(), new_balance);2578 }25792580 fn add_token_index(collection_id: CollectionId, item_index: TokenId, owner: &T::CrossAccountId) -> DispatchResult {2581 // add to account limit2582 if <AccountItemCount<T>>::contains_key(owner.as_sub()) {25832584 // bound Owned tokens by a single address2585 let count = <AccountItemCount<T>>::get(owner.as_sub());2586 ensure!(count < ChainLimit::get().account_token_ownership_limit, Error::<T>::AddressOwnershipLimitExceeded);25872588 <AccountItemCount<T>>::insert(owner.as_sub(), count2589 .checked_add(1)2590 .ok_or(Error::<T>::NumOverflow)?);2591 }2592 else {2593 <AccountItemCount<T>>::insert(owner.as_sub(), 1);2594 }25952596 let list_exists = <AddressTokens<T>>::contains_key(collection_id, owner.as_sub());2597 if list_exists {2598 let mut list = <AddressTokens<T>>::get(collection_id, owner.as_sub());2599 let item_contains = list.contains(&item_index.clone());26002601 if !item_contains {2602 list.push(item_index.clone());2603 }26042605 <AddressTokens<T>>::insert(collection_id, owner.as_sub(), list);2606 } else {2607 let mut itm = Vec::new();2608 itm.push(item_index.clone());2609 <AddressTokens<T>>::insert(collection_id, owner.as_sub(), itm);2610 }26112612 Ok(())2613 }26142615 fn remove_token_index(2616 collection_id: CollectionId,2617 item_index: TokenId,2618 owner: &T::CrossAccountId,2619 ) -> DispatchResult {26202621 // update counter2622 <AccountItemCount<T>>::insert(owner.as_sub(), 2623 <AccountItemCount<T>>::get(owner.as_sub())2624 .checked_sub(1)2625 .ok_or(Error::<T>::NumOverflow)?);262626272628 let list_exists = <AddressTokens<T>>::contains_key(collection_id, owner.as_sub());2629 if list_exists {2630 let mut list = <AddressTokens<T>>::get(collection_id, owner.as_sub());2631 let item_contains = list.contains(&item_index.clone());26322633 if item_contains {2634 list.retain(|&item| item != item_index);2635 <AddressTokens<T>>::insert(collection_id, owner.as_sub(), list);2636 }2637 }26382639 Ok(())2640 }26412642 fn move_token_index(2643 collection_id: CollectionId,2644 item_index: TokenId,2645 old_owner: &T::CrossAccountId,2646 new_owner: &T::CrossAccountId,2647 ) -> DispatchResult {2648 Self::remove_token_index(collection_id, item_index, old_owner)?;2649 Self::add_token_index(collection_id, item_index, new_owner)?;26502651 Ok(())2652 }2653 2654 fn ensure_contract_owned(account: T::AccountId, contract: &T::AccountId) -> DispatchResult {2655 ensure!(<ContractOwner<T>>::get(contract) == Some(account), Error::<T>::NoPermission);26562657 Ok(())2658 }2659}26602661////////////////////////////////////////////////////////////////////////////////////////////////////2662// Economic models2663// #region26642665/// Fee multiplier.2666pub type Multiplier = FixedU128;26672668type BalanceOf<T> = <<T as pallet_transaction_payment::Config>::OnChargeTransaction as pallet_transaction_payment::OnChargeTransaction<T>>::Balance;26692670/// Require the transactor pay for themselves and maybe include a tip to gain additional priority2671/// in the queue.2672#[derive(Encode, Decode, Clone, Eq, PartialEq)]2673pub struct ChargeTransactionPayment<T: Config>(#[codec(compact)] BalanceOf<T>);26742675impl<T: Config + Send + Sync> sp_std::fmt::Debug 2676 for ChargeTransactionPayment<T>2677{2678 #[cfg(feature = "std")]2679 fn fmt(&self, f: &mut sp_std::fmt::Formatter) -> sp_std::fmt::Result {2680 write!(f, "ChargeTransactionPayment<{:?}>", self.0)2681 }2682 #[cfg(not(feature = "std"))]2683 fn fmt(&self, _: &mut sp_std::fmt::Formatter) -> sp_std::fmt::Result {2684 Ok(())2685 }2686}26872688impl<T: Config> ChargeTransactionPayment<T>2689where2690 T::Call: Dispatchable<Info=DispatchInfo, PostInfo=PostDispatchInfo> + IsSubType<Call<T>> + IsSubType<pallet_contracts::Call<T>>,2691 BalanceOf<T>: Send + Sync + From<u64> + FixedPointOperand,2692 T::AccountId: AsRef<[u8]>,2693 T::AccountId: UncheckedFrom<T::Hash>,2694{2695 fn traditional_fee(2696 len: usize,2697 info: &DispatchInfoOf<T::Call>,2698 tip: BalanceOf<T>,2699 ) -> BalanceOf<T>2700 where2701 T::Call: Dispatchable<Info = DispatchInfo>,2702 {2703 <pallet_transaction_payment::Module<T>>::compute_fee(len as u32, info, tip)2704 }27052706 fn get_priority(len: usize, info: &DispatchInfoOf<T::Call>, final_fee: BalanceOf<T>) -> TransactionPriority {2707 let weight_saturation = T::BlockWeights::get().max_block / info.weight.max(1);2708 let max_block_length = *T::BlockLength::get().max.get(DispatchClass::Normal);2709 let len_saturation = max_block_length as u64 / (len as u64).max(1);2710 let coefficient: BalanceOf<T> = weight_saturation2711 .min(len_saturation)2712 .saturated_into::<BalanceOf<T>>();2713 final_fee2714 .saturating_mul(coefficient)2715 .saturated_into::<TransactionPriority>()2716 }27172718 fn withdraw_fee(2719 &self,2720 who: &T::AccountId,2721 call: &T::Call,2722 info: &DispatchInfoOf<T::Call>,2723 len: usize,2724 ) -> Result<2725 (2726 BalanceOf<T>,2727 <<T as pallet_transaction_payment::Config>::OnChargeTransaction as pallet_transaction_payment::OnChargeTransaction<T>>::LiquidityInfo,2728 ),2729 TransactionValidityError,2730 > {2731 let tip = self.0;27322733 let fee = Self::traditional_fee(len, info, tip);27342735 // Only mess with balances if fee is not zero.2736 if fee.is_zero() {2737 return <<T as pallet_transaction_payment::Config>::OnChargeTransaction as pallet_transaction_payment::OnChargeTransaction<T>>::withdraw_fee(who, call, info, fee, tip)2738 .map(|i| (fee, i));2739 }27402741 // Determine who is paying transaction fee based on ecnomic model2742 // Parse call to extract collection ID and access collection sponsor2743 let mut sponsor: Option<T::AccountId> = (|| match IsSubType::<Call<T>>::is_sub_type(call) {2744 Some(Call::create_item(collection_id, _owner, _properties)) => {2745 let collection = <CollectionById<T>>::get(collection_id)?;27462747 // sponsor timeout2748 let block_number = <system::Module<T>>::block_number() as T::BlockNumber;27492750 let limit = collection.limits.sponsor_transfer_timeout;2751 if <CreateItemBasket<T>>::contains_key((collection_id, &who)) {2752 let last_tx_block = <CreateItemBasket<T>>::get((collection_id, &who));2753 let limit_time = last_tx_block + limit.into();2754 if block_number <= limit_time {2755 return None;2756 }2757 }2758 <CreateItemBasket<T>>::insert((collection_id, who.clone()), block_number);27592760 // check free create limit2761 if collection.limits.sponsored_data_size >= (_properties.len() as u32) {2762 collection.sponsorship.sponsor()2763 .cloned()2764 } else {2765 None2766 }2767 }2768 Some(Call::transfer(_new_owner, collection_id, item_id, _value)) => {2769 let collection = <CollectionById<T>>::get(collection_id)?;2770 2771 let mut sponsor_transfer = false;2772 if collection.sponsorship.confirmed() {27732774 let collection_limits = collection.limits;2775 let collection_mode = collection.mode;2776 2777 // sponsor timeout2778 let block_number = <system::Module<T>>::block_number() as T::BlockNumber;2779 sponsor_transfer = match collection_mode {2780 CollectionMode::NFT => {2781 2782 // get correct limit2783 let limit: u32 = if collection_limits.sponsor_transfer_timeout > 0 {2784 collection_limits.sponsor_transfer_timeout2785 } else {2786 ChainLimit::get().nft_sponsor_transfer_timeout2787 };2788 2789 let mut sponsored = true;2790 if <NftTransferBasket<T>>::contains_key(collection_id, item_id) {2791 let last_tx_block = <NftTransferBasket<T>>::get(collection_id, item_id);2792 let limit_time = last_tx_block + limit.into();2793 if block_number <= limit_time {2794 sponsored = false;2795 }2796 }2797 if sponsored {2798 <NftTransferBasket<T>>::insert(collection_id, item_id, block_number);2799 }28002801 sponsored2802 }2803 CollectionMode::Fungible(_) => {2804 2805 // get correct limit2806 let limit: u32 = if collection_limits.sponsor_transfer_timeout > 0 {2807 collection_limits.sponsor_transfer_timeout2808 } else {2809 ChainLimit::get().fungible_sponsor_transfer_timeout2810 };2811 2812 let block_number = <system::Module<T>>::block_number() as T::BlockNumber;2813 let mut sponsored = true;2814 if <FungibleTransferBasket<T>>::contains_key(collection_id, who) {2815 let last_tx_block = <FungibleTransferBasket<T>>::get(collection_id, who);2816 let limit_time = last_tx_block + limit.into();2817 if block_number <= limit_time {2818 sponsored = false;2819 }2820 }2821 if sponsored {2822 <FungibleTransferBasket<T>>::insert(collection_id, who, block_number);2823 }28242825 sponsored2826 }2827 CollectionMode::ReFungible => {2828 2829 // get correct limit2830 let limit: u32 = if collection_limits.sponsor_transfer_timeout > 0 {2831 collection_limits.sponsor_transfer_timeout2832 } else {2833 ChainLimit::get().refungible_sponsor_transfer_timeout2834 };2835 2836 let mut sponsored = true;2837 if <ReFungibleTransferBasket<T>>::contains_key(collection_id, item_id) {2838 let last_tx_block = <ReFungibleTransferBasket<T>>::get(collection_id, item_id);2839 let limit_time = last_tx_block + limit.into();2840 if block_number <= limit_time {2841 sponsored = false;2842 }2843 }2844 if sponsored {2845 <ReFungibleTransferBasket<T>>::insert(collection_id, item_id, block_number);2846 }28472848 sponsored2849 }2850 _ => {2851 false2852 },2853 };2854 }28552856 if !sponsor_transfer {2857 None2858 } else {2859 collection.sponsorship.sponsor()2860 .cloned()2861 }2862 }28632864 Some(Call::set_variable_meta_data(collection_id, item_id, data)) => {2865 let mut sponsor_metadata_changes = false;28662867 let collection = <CollectionById<T>>::get(collection_id)?;28682869 if2870 collection.sponsorship.confirmed() &&2871 // Can't sponsor fungible collection, this tx will be rejected2872 // as invalid2873 !matches!(collection.mode, CollectionMode::Fungible(_)) &&2874 data.len() <= collection.limits.sponsored_data_size as usize2875 {2876 if let Some(rate_limit) = collection.limits.sponsored_data_rate_limit {2877 let block_number = <system::Module<T>>::block_number() as T::BlockNumber;28782879 if <VariableMetaDataBasket<T>>::get(collection_id, item_id)2880 .map(|last_block| block_number - last_block > rate_limit)2881 .unwrap_or(true) 2882 {2883 sponsor_metadata_changes = true;2884 <VariableMetaDataBasket<T>>::insert(collection_id, item_id, block_number);2885 }2886 }2887 }28882889 if !sponsor_metadata_changes {2890 None2891 } else {2892 collection.sponsorship.sponsor().cloned()2893 }2894 }28952896 _ => None,2897 })();28982899 match IsSubType::<pallet_contracts::Call<T>>::is_sub_type(call) {2900 Some(pallet_contracts::Call::call(dest, _value, _gas_limit, _data)) => {29012902 let called_contract: T::AccountId = T::Lookup::lookup((*dest).clone()).unwrap_or(T::AccountId::default());29032904 let owned_contract = <ContractOwner<T>>::get(called_contract.clone()).as_ref() == Some(who);2905 let white_list_enabled = <ContractWhiteListEnabled<T>>::contains_key(called_contract.clone());2906 2907 if !owned_contract && white_list_enabled {2908 if !<ContractWhiteList<T>>::contains_key(called_contract.clone(), who) {2909 return Err(InvalidTransaction::Call.into());2910 }2911 }2912 },2913 _ => {},2914 }29152916 // Sponsor smart contracts2917 sponsor = sponsor.or_else(|| match IsSubType::<pallet_contracts::Call<T>>::is_sub_type(call) {29182919 // On instantiation: set the contract owner2920 Some(pallet_contracts::Call::instantiate(_endowment, _gas_limit, code_hash, _data, salt)) => {29212922 let new_contract_address = <pallet_contracts::Module<T>>::contract_address(2923 &who,2924 code_hash,2925 salt,2926 );2927 <ContractOwner<T>>::insert(new_contract_address.clone(), who.clone());29282929 None2930 },29312932 // On instantiation with code: set the contract owner2933 Some(pallet_contracts::Call::instantiate_with_code(_endowment, _gas_limit, _code, _data, _salt)) => {29342935 let new_contract_address = <pallet_contracts::Module<T>>::contract_address(2936 &who,2937 &T::Hashing::hash(&_code),2938 _salt,2939 );29402941 <ContractOwner<T>>::insert(new_contract_address.clone(), who.clone());29422943 None2944 }29452946 // When the contract is called, check if the sponsoring is enabled and pay fees from contract endowment if it is2947 Some(pallet_contracts::Call::call(dest, _value, _gas_limit, _data)) => {29482949 let called_contract: T::AccountId = T::Lookup::lookup((*dest).clone()).unwrap_or(T::AccountId::default());29502951 let mut sponsor_transfer = false;2952 if <ContractSponsoringRateLimit<T>>::contains_key(called_contract.clone()) {2953 let last_tx_block = <ContractSponsorBasket<T>>::get((&called_contract, &who));2954 let block_number = <system::Module<T>>::block_number() as T::BlockNumber;2955 let rate_limit = <ContractSponsoringRateLimit<T>>::get(&called_contract);2956 let limit_time = last_tx_block + rate_limit;29572958 if block_number >= limit_time {2959 <ContractSponsorBasket<T>>::insert((called_contract.clone(), who.clone()), block_number);2960 sponsor_transfer = true;2961 }2962 } else {2963 sponsor_transfer = false;2964 }2965 2966 if sponsor_transfer {2967 if <ContractSelfSponsoring<T>>::contains_key(called_contract.clone()) {2968 if <ContractSelfSponsoring<T>>::get(called_contract.clone()) {2969 return Some(called_contract);2970 }2971 }2972 }29732974 None2975 },29762977 _ => None,2978 });29792980 let who_pays_fee = sponsor.unwrap_or_else(|| who.clone());29812982 <<T as pallet_transaction_payment::Config>::OnChargeTransaction as pallet_transaction_payment::OnChargeTransaction<T>>::withdraw_fee(&who_pays_fee, call, info, fee, tip)2983 .map(|i| (fee, i))2984 }2985}298629872988impl<T: Config + Send + Sync> SignedExtension2989 for ChargeTransactionPayment<T>2990where2991 BalanceOf<T>: Send + Sync + From<u64> + FixedPointOperand,2992 T::Call: Dispatchable<Info = DispatchInfo, PostInfo = PostDispatchInfo> + IsSubType<Call<T>> + IsSubType<pallet_contracts::Call<T>>,2993 T::AccountId: AsRef<[u8]>,2994 T::AccountId: UncheckedFrom<T::Hash>,2995{2996 const IDENTIFIER: &'static str = "ChargeTransactionPayment";2997 type AccountId = T::AccountId;2998 type Call = T::Call;2999 type AdditionalSigned = ();3000 type Pre = (3001 // tip3002 BalanceOf<T>,3003 // who pays fee3004 Self::AccountId,3005 // imbalance resulting from withdrawing the fee3006 <<T as pallet_transaction_payment::Config>::OnChargeTransaction as pallet_transaction_payment::OnChargeTransaction<T>>::LiquidityInfo,3007 );3008 fn additional_signed(&self) -> sp_std::result::Result<(), TransactionValidityError> {3009 Ok(())3010 }30113012 fn validate(3013 &self,3014 who: &Self::AccountId,3015 call: &Self::Call,3016 info: &DispatchInfoOf<Self::Call>,3017 len: usize,3018 ) -> TransactionValidity {3019 let (fee, _) = self.withdraw_fee(who, call, info, len)?;3020 Ok(ValidTransaction {3021 priority: Self::get_priority(len, info, fee),3022 ..Default::default()3023 })3024 }30253026 fn pre_dispatch(3027 self,3028 who: &Self::AccountId,3029 call: &Self::Call,3030 info: &DispatchInfoOf<Self::Call>,3031 len: usize,3032 ) -> Result<Self::Pre, TransactionValidityError> {3033 let (_fee, imbalance) = self.withdraw_fee(who, call, info, len)?;3034 Ok((self.0, who.clone(), imbalance))3035 }30363037 fn post_dispatch(3038 pre: Self::Pre,3039 info: &DispatchInfoOf<Self::Call>,3040 post_info: &PostDispatchInfoOf<Self::Call>,3041 len: usize,3042 _result: &DispatchResult,3043 ) -> Result<(), TransactionValidityError> {3044 let (tip, who, imbalance) = pre;3045 let actual_fee = pallet_transaction_payment::Module::<T>::compute_actual_fee(3046 len as u32,3047 info,3048 post_info,3049 tip,3050 );3051 <T as pallet_transaction_payment::Config>::OnChargeTransaction::correct_and_deposit_fee(&who, info, post_info, actual_fee, tip, imbalance)?;3052 Ok(())3053 }3054}30553056// #endregion30573058sp_api::decl_runtime_apis! {3059 pub trait NftApi {3060 /// Used for ethereum integration3061 fn eth_contract_code(account: H160) -> Option<Vec<u8>>;3062 }3063}