difftreelog
feat eth address mapping
in: master
5 files changed
pallets/nft/src/eth/account.rsdiffbeforeafterboth--- /dev/null
+++ b/pallets/nft/src/eth/account.rs
@@ -0,0 +1,135 @@
+use crate::Config;
+use codec::{Encode, EncodeLike, Decode};
+use sp_core::{H160, H256, crypto::AccountId32};
+use core::cmp::Ordering;
+#[cfg(feature = "std")]
+use serde::{Serialize, Deserialize};
+use pallet_evm::AddressMapping;
+use sp_std::vec::Vec;
+use sp_std::clone::Clone;
+
+pub trait CrossAccountId<AccountId>:
+ Encode + EncodeLike + Decode +
+ Clone + PartialEq + Ord + core::fmt::Debug // +
+ // Serialize + Deserialize<'static>
+{
+ fn as_sub(&self) -> &AccountId;
+ fn as_eth(&self) -> &H160;
+
+ fn from_sub(account: AccountId) -> Self;
+ fn from_eth(account: H160) -> Self;
+}
+
+#[derive(Eq)]
+#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]
+pub struct BasicCrossAccountId<T: Config> {
+ /// If true - then ethereum is canonical encoding
+ from_ethereum: bool,
+ substrate: T::AccountId,
+ ethereum: H160,
+}
+
+impl<T: Config> core::fmt::Debug for BasicCrossAccountId<T> {
+ fn fmt(&self, fmt: &mut core::fmt::Formatter) -> core::fmt::Result {
+ if self.from_ethereum {
+ fmt.debug_tuple("CrossAccountId::Ethereum")
+ .field(&self.ethereum)
+ .finish()
+ } else {
+ fmt.debug_tuple("CrossAccountId::Substrate")
+ .field(&self.substrate)
+ .finish()
+ }
+ }
+}
+
+impl<T: Config> PartialOrd for BasicCrossAccountId<T> {
+ fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+ Some(self.substrate.cmp(&other.substrate))
+ }
+}
+
+impl<T: Config> Ord for BasicCrossAccountId<T> {
+ fn cmp(&self, other: &Self) -> Ordering {
+ self.partial_cmp(other).expect("substrate account is total ordered")
+ }
+}
+
+impl<T: Config> PartialEq for BasicCrossAccountId<T> {
+ fn eq(&self, other: &Self) -> bool {
+ if self.from_ethereum == other.from_ethereum {
+ self.substrate == other.substrate && self.ethereum == other.ethereum
+ } else if self.from_ethereum {
+ // ethereum is canonical encoding, but we need to compare derived address
+ self.substrate == other.substrate
+ } else {
+ self.ethereum == other.ethereum
+ }
+ }
+}
+impl<T: Config> Clone for BasicCrossAccountId<T> {
+ fn clone(&self) -> Self {
+ Self {
+ from_ethereum: self.from_ethereum,
+ substrate: self.substrate.clone(),
+ ethereum: self.ethereum,
+ }
+ }
+}
+impl<T: Config> Encode for BasicCrossAccountId<T> {
+ fn encode(&self) -> Vec<u8> {
+ let as_result = if !self.from_ethereum {
+ Ok(self.substrate.clone())
+ } else {
+ Err(self.ethereum)
+ };
+ as_result.encode()
+ }
+}
+impl<T: Config> EncodeLike for BasicCrossAccountId<T> {}
+impl<T: Config> Decode for BasicCrossAccountId<T> {
+ fn decode<I>(input: &mut I) -> Result<Self, codec::Error>
+ where I: codec::Input
+ {
+ Ok(match <Result<T::AccountId, H160>>::decode(input)? {
+ Ok(s) => Self::from_sub(s),
+ Err(e) => Self::from_eth(e),
+ })
+ }
+}
+impl<T: Config> CrossAccountId<T::AccountId> for BasicCrossAccountId<T> {
+ fn as_sub(&self) -> &T::AccountId {
+ &self.substrate
+ }
+ fn as_eth(&self) -> &H160 {
+ &self.ethereum
+ }
+ fn from_sub(substrate: T::AccountId) -> Self {
+ Self {
+ ethereum: T::EvmBackwardsAddressMapping::from_account_id(substrate.clone()),
+ substrate,
+ from_ethereum: false,
+ }
+ }
+ fn from_eth(ethereum: H160) -> Self {
+ Self {
+ ethereum,
+ substrate: T::EvmAddressMapping::into_account_id(ethereum),
+ from_ethereum: true,
+ }
+ }
+}
+
+pub trait EvmBackwardsAddressMapping<AccountId> {
+ fn from_account_id(account_id: AccountId) -> H160;
+}
+
+/// Should have same mapping as EnsureAddressTruncated
+pub struct MapBackwardsAddressTruncated;
+impl EvmBackwardsAddressMapping<AccountId32> for MapBackwardsAddressTruncated {
+ fn from_account_id(account_id: AccountId32) -> H160 {
+ let mut out = [0; 20];
+ out.copy_from_slice(&(account_id.as_ref() as &[u8])[0..20]);
+ H160(out)
+ }
+}
\ No newline at end of file
pallets/nft/src/eth/mod.rsdiffbeforeafterboth--- /dev/null
+++ b/pallets/nft/src/eth/mod.rs
@@ -0,0 +1,2 @@
+pub mod account;
+use account::CrossAccountId;
pallets/nft/src/lib.rsdiffbeforeafterboth1//2// This file is subject to the terms and conditions defined in3// file 'LICENSE', which is part of this source code package.4//56#![recursion_limit = "1024"]78#![cfg_attr(not(feature = "std"), no_std)]910#[cfg(feature = "std")]11pub use std::*;1213#[cfg(feature = "std")]14pub use serde::*;1516use core::ops::{Deref, DerefMut};17use codec::{Decode, Encode};18pub use frame_support::{19 construct_runtime, decl_event, decl_module, decl_storage, decl_error,20 dispatch::DispatchResult,21 ensure, fail, parameter_types,22 traits::{23 Currency, ExistenceRequirement, Get, Imbalance, KeyOwnerProofSystem, OnUnbalanced,24 Randomness, IsSubType, WithdrawReasons,25 },26 weights::{27 constants::{BlockExecutionWeight, ExtrinsicBaseWeight, RocksDbWeight, WEIGHT_PER_SECOND},28 DispatchInfo, GetDispatchInfo, IdentityFee, Pays, PostDispatchInfo, Weight,29 WeightToFeePolynomial, DispatchClass,30 },31 StorageValue,32 transactional,33};3435use frame_system::{self as system, ensure_signed, ensure_root};36use sp_runtime::sp_std::prelude::Vec;37use sp_runtime::{38 traits::{39 Hash, DispatchInfoOf, Dispatchable, PostDispatchInfoOf, Saturating, SaturatedConversion, SignedExtension, Zero,40 },41 transaction_validity::{42 TransactionPriority, InvalidTransaction, TransactionValidity, TransactionValidityError, ValidTransaction,43 },44 FixedPointOperand, FixedU128,45};46use sp_runtime::traits::StaticLookup;47use pallet_contracts::chain_extension::UncheckedFrom;48use pallet_transaction_payment::OnChargeTransaction;4950#[cfg(test)]51mod mock;5253#[cfg(test)]54mod tests;5556mod default_weights;5758pub const MAX_DECIMAL_POINTS: DecimalPoints = 30;59pub const MAX_REFUNGIBLE_PIECES: u128 = 1_000_000_000_000_000_000_000;60pub const MAX_SPONSOR_TIMEOUT: u32 = 10_368_000;61pub const MAX_TOKEN_OWNERSHIP: u32 = 10_000_000;6263// Structs64// #region6566pub type CollectionId = u32;67pub type TokenId = u32;68pub type DecimalPoints = u8;6970#[derive(Encode, Decode, Eq, Debug, Clone, PartialEq)]71#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]72pub enum CollectionMode {73 Invalid,74 NFT,75 // decimal points76 Fungible(DecimalPoints),77 ReFungible,78}7980impl Default for CollectionMode {81 fn default() -> Self {82 Self::Invalid83 }84}8586impl Into<u8> for CollectionMode {87 fn into(self) -> u8 {88 match self {89 CollectionMode::Invalid => 0,90 CollectionMode::NFT => 1,91 CollectionMode::Fungible(_) => 2,92 CollectionMode::ReFungible => 3,93 }94 }95}9697#[derive(Encode, Decode, Eq, Debug, Clone, PartialEq)]98#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]99pub enum AccessMode {100 Normal,101 WhiteList,102}103impl Default for AccessMode {104 fn default() -> Self {105 Self::Normal106 }107}108109#[derive(Encode, Decode, Eq, Debug, Clone, PartialEq)]110#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]111pub enum SchemaVersion {112 ImageURL,113 Unique,114}115impl Default for SchemaVersion {116 fn default() -> Self {117 Self::ImageURL118 }119}120121#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]122#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]123pub struct Ownership<AccountId> {124 pub owner: AccountId,125 pub fraction: u128,126}127128#[derive(Encode, Decode, Debug, Clone, PartialEq)]129#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]130pub enum SponsorshipState<AccountId> {131 /// The fees are applied to the transaction sender132 Disabled,133 Unconfirmed(AccountId),134 /// Transactions are sponsored by specified account135 Confirmed(AccountId),136}137138impl<AccountId> SponsorshipState<AccountId> {139 fn sponsor(&self) -> Option<&AccountId> {140 match self {141 Self::Confirmed(sponsor) => Some(sponsor),142 _ => None,143 }144 }145146 fn pending_sponsor(&self) -> Option<&AccountId> {147 match self {148 Self::Unconfirmed(sponsor) | Self::Confirmed(sponsor) => Some(sponsor),149 _ => None,150 }151 }152153 fn confirmed(&self) -> bool {154 matches!(self, Self::Confirmed(_))155 }156}157158impl<T> Default for SponsorshipState<T> {159 fn default() -> Self {160 Self::Disabled161 }162}163164#[derive(Encode, Decode, Clone, PartialEq)]165#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]166pub struct Collection<T: Config> {167 pub owner: T::AccountId,168 pub mode: CollectionMode,169 pub access: AccessMode,170 pub decimal_points: DecimalPoints,171 pub name: Vec<u16>, // 64 include null escape char172 pub description: Vec<u16>, // 256 include null escape char173 pub token_prefix: Vec<u8>, // 16 include null escape char174 pub mint_mode: bool,175 pub offchain_schema: Vec<u8>,176 pub schema_version: SchemaVersion,177 pub sponsorship: SponsorshipState<T::AccountId>,178 pub limits: CollectionLimits<T::BlockNumber>, // Collection private restrictions 179 pub variable_on_chain_schema: Vec<u8>, //180 pub const_on_chain_schema: Vec<u8>, //181}182183pub struct CollectionHandle<T: Config> {184 pub id: CollectionId,185 collection: Collection<T>,186}187188impl<T: Config> Deref for CollectionHandle<T> {189 type Target = Collection<T>;190191 fn deref(&self) -> &Self::Target {192 &self.collection193 }194}195196impl<T: Config> DerefMut for CollectionHandle<T> {197 fn deref_mut(&mut self) -> &mut Self::Target {198 &mut self.collection199 }200}201202#[derive(Encode, Decode, Debug, Clone, PartialEq)]203#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]204pub struct NftItemType<AccountId> {205 pub owner: AccountId,206 pub const_data: Vec<u8>,207 pub variable_data: Vec<u8>,208}209210#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]211#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]212pub struct FungibleItemType {213 pub value: u128,214}215216#[derive(Encode, Decode, Debug, Clone, PartialEq)]217#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]218pub struct ReFungibleItemType<AccountId> {219 pub owner: Vec<Ownership<AccountId>>,220 pub const_data: Vec<u8>,221 pub variable_data: Vec<u8>,222}223224// #[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]225// #[cfg_attr(feature = "std", derive(Serialize, Deserialize))]226// pub struct VestingItem<AccountId, Moment> {227// pub sender: AccountId,228// pub recipient: AccountId,229// pub collection_id: CollectionId,230// pub item_id: TokenId,231// pub amount: u64,232// pub vesting_date: Moment,233// }234235#[derive(Encode, Decode, Debug, Clone, PartialEq)]236#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]237pub struct CollectionLimits<BlockNumber: Encode + Decode> {238 pub account_token_ownership_limit: u32,239 pub sponsored_data_size: u32,240 /// None - setVariableMetadata is not sponsored241 /// Some(v) - setVariableMetadata is sponsored 242 /// if there is v block between txs243 pub sponsored_data_rate_limit: Option<BlockNumber>,244 pub token_limit: u32,245246 // Timeouts for item types in passed blocks247 pub sponsor_transfer_timeout: u32,248 pub owner_can_transfer: bool,249 pub owner_can_destroy: bool,250}251252impl<BlockNumber: Encode + Decode> Default for CollectionLimits<BlockNumber> {253 fn default() -> Self {254 Self { 255 account_token_ownership_limit: 10_000_000, 256 token_limit: u32::max_value(),257 sponsored_data_size: u32::MAX, 258 sponsored_data_rate_limit: None,259 sponsor_transfer_timeout: 14400,260 owner_can_transfer: true,261 owner_can_destroy: true262 }263 }264}265266#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]267#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]268pub struct ChainLimits {269 pub collection_numbers_limit: u32,270 pub account_token_ownership_limit: u32,271 pub collections_admins_limit: u64,272 pub custom_data_limit: u32,273274 // Timeouts for item types in passed blocks275 pub nft_sponsor_transfer_timeout: u32,276 pub fungible_sponsor_transfer_timeout: u32,277 pub refungible_sponsor_transfer_timeout: u32,278279 // Schema limits280 pub offchain_schema_limit: u32,281 pub variable_on_chain_schema_limit: u32,282 pub const_on_chain_schema_limit: u32,283}284285pub trait WeightInfo {286 fn create_collection() -> Weight;287 fn destroy_collection() -> Weight;288 fn add_to_white_list() -> Weight;289 fn remove_from_white_list() -> Weight;290 fn set_public_access_mode() -> Weight;291 fn set_mint_permission() -> Weight;292 fn change_collection_owner() -> Weight;293 fn add_collection_admin() -> Weight;294 fn remove_collection_admin() -> Weight;295 fn set_collection_sponsor() -> Weight;296 fn confirm_sponsorship() -> Weight;297 fn remove_collection_sponsor() -> Weight;298 fn create_item(s: usize) -> Weight;299 fn burn_item() -> Weight;300 fn transfer() -> Weight;301 fn approve() -> Weight;302 fn transfer_from() -> Weight;303 fn set_offchain_schema() -> Weight;304 fn set_const_on_chain_schema() -> Weight;305 fn set_variable_on_chain_schema() -> Weight;306 fn set_variable_meta_data() -> Weight;307 fn enable_contract_sponsoring() -> Weight;308 fn set_schema_version() -> Weight;309 fn set_chain_limits() -> Weight;310 fn set_contract_sponsoring_rate_limit() -> Weight;311 fn set_variable_meta_data_sponsoring_rate_limit() -> Weight;312 fn toggle_contract_white_list() -> Weight;313 fn add_to_contract_white_list() -> Weight;314 fn remove_from_contract_white_list() -> Weight;315 fn set_collection_limits() -> Weight;316}317318#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]319#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]320pub struct CreateNftData {321 pub const_data: Vec<u8>,322 pub variable_data: Vec<u8>,323}324325#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]326#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]327pub struct CreateFungibleData {328 pub value: u128,329}330331#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]332#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]333pub struct CreateReFungibleData {334 pub const_data: Vec<u8>,335 pub variable_data: Vec<u8>,336 pub pieces: u128,337}338339#[derive(Encode, Decode, Debug, Clone, PartialEq)]340#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]341pub enum CreateItemData {342 NFT(CreateNftData),343 Fungible(CreateFungibleData),344 ReFungible(CreateReFungibleData),345}346347impl CreateItemData {348 pub fn len(&self) -> usize {349 let len = match self {350 CreateItemData::NFT(data) => data.variable_data.len() + data.const_data.len(),351 CreateItemData::ReFungible(data) => data.variable_data.len() + data.const_data.len(),352 _ => 0353 };354 355 return len;356 }357}358359impl From<CreateNftData> for CreateItemData {360 fn from(item: CreateNftData) -> Self {361 CreateItemData::NFT(item)362 }363}364365impl From<CreateReFungibleData> for CreateItemData {366 fn from(item: CreateReFungibleData) -> Self {367 CreateItemData::ReFungible(item)368 }369}370371impl From<CreateFungibleData> for CreateItemData {372 fn from(item: CreateFungibleData) -> Self {373 CreateItemData::Fungible(item)374 }375}376377378decl_error! {379 /// Error for non-fungible-token module.380 pub enum Error for Module<T: Config> {381 /// Total collections bound exceeded.382 TotalCollectionsLimitExceeded,383 /// Decimal_points parameter must be lower than MAX_DECIMAL_POINTS constant, currently it is 30.384 CollectionDecimalPointLimitExceeded, 385 /// Collection name can not be longer than 63 char.386 CollectionNameLimitExceeded, 387 /// Collection description can not be longer than 255 char.388 CollectionDescriptionLimitExceeded, 389 /// Token prefix can not be longer than 15 char.390 CollectionTokenPrefixLimitExceeded,391 /// This collection does not exist.392 CollectionNotFound,393 /// Item not exists.394 TokenNotFound,395 /// Admin not found396 AdminNotFound,397 /// Arithmetic calculation overflow.398 NumOverflow, 399 /// Account already has admin role.400 AlreadyAdmin, 401 /// You do not own this collection.402 NoPermission,403 /// This address is not set as sponsor, use setCollectionSponsor first.404 ConfirmUnsetSponsorFail,405 /// Collection is not in mint mode.406 PublicMintingNotAllowed,407 /// Sender parameter and item owner must be equal.408 MustBeTokenOwner,409 /// Item balance not enough.410 TokenValueTooLow,411 /// Size of item is too large.412 NftSizeLimitExceeded,413 /// No approve found414 ApproveNotFound,415 /// Requested value more than approved.416 TokenValueNotEnough,417 /// Only approved addresses can call this method.418 ApproveRequired,419 /// Address is not in white list.420 AddresNotInWhiteList,421 /// Number of collection admins bound exceeded.422 CollectionAdminsLimitExceeded,423 /// Owned tokens by a single address bound exceeded.424 AddressOwnershipLimitExceeded,425 /// Length of items properties must be greater than 0.426 EmptyArgument,427 /// const_data exceeded data limit.428 TokenConstDataLimitExceeded,429 /// variable_data exceeded data limit.430 TokenVariableDataLimitExceeded,431 /// Not NFT item data used to mint in NFT collection.432 NotNftDataUsedToMintNftCollectionToken,433 /// Not Fungible item data used to mint in Fungible collection.434 NotFungibleDataUsedToMintFungibleCollectionToken,435 /// Not Re Fungible item data used to mint in Re Fungible collection.436 NotReFungibleDataUsedToMintReFungibleCollectionToken,437 /// Unexpected collection type.438 UnexpectedCollectionType,439 /// Can't store metadata in fungible tokens.440 CantStoreMetadataInFungibleTokens,441 /// Collection token limit exceeded442 CollectionTokenLimitExceeded,443 /// Account token limit exceeded per collection444 AccountTokenLimitExceeded,445 /// Collection limit bounds per collection exceeded446 CollectionLimitBoundsExceeded,447 /// Tried to enable permissions which are only permitted to be disabled448 OwnerPermissionsCantBeReverted,449 /// Schema data size limit bound exceeded450 SchemaDataLimitExceeded,451 /// Maximum refungibility exceeded452 WrongRefungiblePieces,453 /// createRefungible should be called with one owner454 BadCreateRefungibleCall,455 }456}457458pub trait Config: system::Config + Sized + pallet_transaction_payment::Config + pallet_contracts::Config {459 type Event: From<Event<Self>> + Into<<Self as system::Config>::Event>;460461 /// Weight information for extrinsics in this pallet.462 type WeightInfo: WeightInfo;463464 type Currency: Currency<Self::AccountId>;465 type CollectionCreationPrice: Get<<<Self as Config>::Currency as Currency<Self::AccountId>>::Balance>;466 type TreasuryAccountId: Get<Self::AccountId>;467}468469#[cfg(feature = "runtime-benchmarks")]470mod benchmarking;471472// #endregion473474// # Used definitions475//476// ## User control levels477//478// chain-controlled - key is uncontrolled by user479// i.e autoincrementing index480// can use non-cryptographic hash481// real - key is controlled by user482// but it is hard to generate enough colliding values, i.e owner of signed txs483// can use non-cryptographic hash484// controlled - key is completly controlled by users485// i.e maps with mutable keys486// should use cryptographic hash487//488// ## User control level downgrade reasons489//490// ?1 - chain-controlled -> controlled491// collections/tokens can be destroyed, resulting in massive holes492// ?2 - chain-controlled -> controlled493// same as ?1, but can be only added, resulting in easier exploitation494// ?3 - real -> controlled495// no confirmation required, so addresses can be easily generated496decl_storage! {497 trait Store for Module<T: Config> as Nft {498499 //#region Private members500 /// Id of next collection501 CreatedCollectionCount: u32;502 /// Used for migrations503 ChainVersion: u64;504 /// Id of last collection token505 /// Collection id (controlled?1)506 ItemListIndex: map hasher(blake2_128_concat) CollectionId => TokenId;507 //#endregion508509 //#region Chain limits struct510 pub ChainLimit get(fn chain_limit) config(): ChainLimits;511 //#endregion512513 //#region Bound counters514 /// Amount of collections destroyed, used for total amount tracking with515 /// CreatedCollectionCount516 DestroyedCollectionCount: u32;517 /// Total amount of account owned tokens (NFTs + RFTs + unique fungibles)518 /// Account id (real)519 pub AccountItemCount get(fn account_item_count): map hasher(twox_64_concat) T::AccountId => u32;520 //#endregion521522 //#region Basic collections523 /// Collection info524 /// Collection id (controlled?1)525 pub CollectionById get(fn collection_id) config(): map hasher(blake2_128_concat) CollectionId => Option<Collection<T>> = None;526 /// List of collection admins527 /// Collection id (controlled?2)528 pub AdminList get(fn admin_list_collection): map hasher(blake2_128_concat) CollectionId => Vec<T::AccountId>;529 /// Whitelisted collection users530 /// Collection id (controlled?2), user id (controlled?3)531 pub WhiteList get(fn white_list): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) T::AccountId => bool;532 //#endregion533534 /// How many of collection items user have535 /// Collection id (controlled?2), account id (real)536 pub Balance get(fn balance_count): double_map hasher(blake2_128_concat) CollectionId, hasher(twox_64_concat) T::AccountId => u128;537538 /// Amount of items which spender can transfer out of owners account (via transferFrom)539 /// Collection id (controlled?2), (token id (controlled ?2) + owner account id (real) + spender account id (controlled?3))540 /// TODO: Off chain worker should remove from this map when token gets removed541 pub Allowances get(fn approved): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) (TokenId, T::AccountId, T::AccountId) => u128;542543 //#region Item collections544 /// Collection id (controlled?2), token id (controlled?1)545 pub NftItemList get(fn nft_item_id) config(): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => Option<NftItemType<T::AccountId>>;546 /// Collection id (controlled?2), owner (controlled?2)547 pub FungibleItemList get(fn fungible_item_id) config(): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) T::AccountId => FungibleItemType;548 /// Collection id (controlled?2), token id (controlled?1)549 pub ReFungibleItemList get(fn refungible_item_id) config(): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => Option<ReFungibleItemType<T::AccountId>>;550 //#endregion551552 //#region Index list553 /// Collection id (controlled?2), tokens owner (controlled?2)554 pub AddressTokens get(fn address_tokens): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) T::AccountId => Vec<TokenId>;555 //#endregion556557 //#region Tokens transfer rate limit baskets558 /// (Collection id (controlled?2), who created (real))559 /// TODO: Off chain worker should remove from this map when collection gets removed560 pub CreateItemBasket get(fn create_item_basket): map hasher(blake2_128_concat) (CollectionId, T::AccountId) => T::BlockNumber;561 /// Collection id (controlled?2), token id (controlled?2)562 pub NftTransferBasket get(fn nft_transfer_basket): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => T::BlockNumber;563 /// Collection id (controlled?2), owning user (real)564 pub FungibleTransferBasket get(fn fungible_transfer_basket): double_map hasher(blake2_128_concat) CollectionId, hasher(twox_64_concat) T::AccountId => T::BlockNumber;565 /// Collection id (controlled?2), token id (controlled?2)566 pub ReFungibleTransferBasket get(fn refungible_transfer_basket): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => T::BlockNumber;567 //#endregion568569 /// Variable metadata sponsoring570 /// Collection id (controlled?2), token id (controlled?2)571 pub VariableMetaDataBasket get(fn variable_meta_data_basket): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => Option<T::BlockNumber> = None;572 573 //#region Contract Sponsorship and Ownership574 /// Contract address (real)575 pub ContractOwner get(fn contract_owner): map hasher(twox_64_concat) T::AccountId => Option<T::AccountId>;576 /// Contract address (real)577 pub ContractSelfSponsoring get(fn contract_self_sponsoring): map hasher(twox_64_concat) T::AccountId => bool;578 /// (Contract address(real), caller (real))579 pub ContractSponsorBasket get(fn contract_sponsor_basket): map hasher(twox_64_concat) (T::AccountId, T::AccountId) => T::BlockNumber;580 /// Contract address (real)581 pub ContractSponsoringRateLimit get(fn contract_sponsoring_rate_limit): map hasher(twox_64_concat) T::AccountId => T::BlockNumber;582 /// Contract address (real)583 pub ContractWhiteListEnabled get(fn contract_white_list_enabled): map hasher(twox_64_concat) T::AccountId => bool; 584 /// Contract address (real) => Whitelisted user (controlled?3)585 pub ContractWhiteList get(fn contract_white_list): double_map hasher(twox_64_concat) T::AccountId, hasher(blake2_128_concat) T::AccountId => bool; 586 //#endregion587 }588 add_extra_genesis {589 build(|config: &GenesisConfig<T>| {590 // Modification of storage591 for (_num, _c) in &config.collection_id {592 <Module<T>>::init_collection(_c);593 }594595 for (_num, _c, _i) in &config.nft_item_id {596 <Module<T>>::init_nft_token(*_c, _i);597 }598599 for (collection_id, account_id, fungible_item) in &config.fungible_item_id {600 <Module<T>>::init_fungible_token(*collection_id, account_id, fungible_item);601 }602603 for (_num, _c, _i) in &config.refungible_item_id {604 <Module<T>>::init_refungible_token(*_c, _i);605 }606 })607 }608}609610decl_event!(611 pub enum Event<T>612 where613 AccountId = <T as system::Config>::AccountId,614 {615 /// New collection was created616 /// 617 /// # Arguments618 /// 619 /// * collection_id: Globally unique identifier of newly created collection.620 /// 621 /// * mode: [CollectionMode] converted into u8.622 /// 623 /// * account_id: Collection owner.624 CollectionCreated(CollectionId, u8, AccountId),625626 /// New item was created.627 /// 628 /// # Arguments629 /// 630 /// * collection_id: Id of the collection where item was created.631 /// 632 /// * item_id: Id of an item. Unique within the collection.633 ///634 /// * recipient: Owner of newly created item 635 ItemCreated(CollectionId, TokenId, AccountId),636637 /// Collection item was burned.638 /// 639 /// # Arguments640 /// 641 /// collection_id.642 /// 643 /// item_id: Identifier of burned NFT.644 ItemDestroyed(CollectionId, TokenId),645646 /// Item was transferred647 ///648 /// * collection_id: Id of collection to which item is belong649 ///650 /// * item_id: Id of an item651 ///652 /// * sender: Original owner of item653 ///654 /// * recipient: New owner of item655 ///656 /// * amount: Always 1 for NFT657 Transfer(CollectionId, TokenId, AccountId, AccountId, u128),658659 /// * collection_id660 ///661 /// * item_id662 ///663 /// * sender664 ///665 /// * spender666 ///667 /// * amount668 Approved(CollectionId, TokenId, AccountId, AccountId, u128),669 }670);671672decl_module! {673 pub struct Module<T: Config> for enum Call 674 where 675 origin: T::Origin676 {677 fn deposit_event() = default;678 type Error = Error<T>;679680 fn on_initialize(now: T::BlockNumber) -> Weight {681 0682 }683684 /// 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.685 /// 686 /// # Permissions687 /// 688 /// * Anyone.689 /// 690 /// # Arguments691 /// 692 /// * collection_name: UTF-16 string with collection name (limit 64 characters), will be stored as zero-terminated.693 /// 694 /// * collection_description: UTF-16 string with collection description (limit 256 characters), will be stored as zero-terminated.695 /// 696 /// * token_prefix: UTF-8 string with token prefix.697 /// 698 /// * mode: [CollectionMode] collection type and type dependent data.699 // returns collection ID700 #[weight = <T as Config>::WeightInfo::create_collection()]701 #[transactional]702 pub fn create_collection(origin,703 collection_name: Vec<u16>,704 collection_description: Vec<u16>,705 token_prefix: Vec<u8>,706 mode: CollectionMode) -> DispatchResult {707708 // Anyone can create a collection709 let who = ensure_signed(origin)?;710711 // Take a (non-refundable) deposit of collection creation712 let mut imbalance = <<<T as Config>::Currency as Currency<T::AccountId>>::PositiveImbalance>::zero();713 imbalance.subsume(<<T as Config>::Currency as Currency<T::AccountId>>::deposit_creating(714 &T::TreasuryAccountId::get(),715 T::CollectionCreationPrice::get(),716 ));717 <T as Config>::Currency::settle(718 &who,719 imbalance,720 WithdrawReasons::TRANSFER,721 ExistenceRequirement::KeepAlive,722 ).map_err(|_| Error::<T>::NoPermission)?;723724 let decimal_points = match mode {725 CollectionMode::Fungible(points) => points,726 _ => 0727 };728729 let chain_limit = ChainLimit::get();730731 let created_count = CreatedCollectionCount::get();732 let destroyed_count = DestroyedCollectionCount::get();733734 // bound Total number of collections735 ensure!(created_count - destroyed_count < chain_limit.collection_numbers_limit, Error::<T>::TotalCollectionsLimitExceeded);736737 // check params738 ensure!(decimal_points <= MAX_DECIMAL_POINTS, Error::<T>::CollectionDecimalPointLimitExceeded);739 ensure!(collection_name.len() <= 64, Error::<T>::CollectionNameLimitExceeded);740 ensure!(collection_description.len() <= 256, Error::<T>::CollectionDescriptionLimitExceeded);741 ensure!(token_prefix.len() <= 16, Error::<T>::CollectionTokenPrefixLimitExceeded);742743 // Generate next collection ID744 let next_id = created_count745 .checked_add(1)746 .ok_or(Error::<T>::NumOverflow)?;747748 CreatedCollectionCount::put(next_id);749750 let limits = CollectionLimits {751 sponsored_data_size: chain_limit.custom_data_limit,752 ..Default::default()753 };754755 // Create new collection756 let new_collection = Collection {757 owner: who.clone(),758 name: collection_name,759 mode: mode.clone(),760 mint_mode: false,761 access: AccessMode::Normal,762 description: collection_description,763 decimal_points: decimal_points,764 token_prefix: token_prefix,765 offchain_schema: Vec::new(),766 schema_version: SchemaVersion::ImageURL,767 sponsorship: SponsorshipState::Disabled,768 variable_on_chain_schema: Vec::new(),769 const_on_chain_schema: Vec::new(),770 limits,771 };772773 // Add new collection to map774 <CollectionById<T>>::insert(next_id, new_collection);775776 // call event777 Self::deposit_event(RawEvent::CollectionCreated(next_id, mode.into(), who.clone()));778779 Ok(())780 }781782 /// **DANGEROUS**: Destroys collection and all NFTs within this collection. Users irrecoverably lose their assets and may lose real money.783 /// 784 /// # Permissions785 /// 786 /// * Collection Owner.787 /// 788 /// # Arguments789 /// 790 /// * collection_id: collection to destroy.791 #[weight = <T as Config>::WeightInfo::destroy_collection()]792 #[transactional]793 pub fn destroy_collection(origin, collection_id: CollectionId) -> DispatchResult {794795 let sender = ensure_signed(origin)?;796 let collection = Self::get_collection(collection_id)?;797 Self::check_owner_permissions(&collection, sender)?;798 if !collection.limits.owner_can_destroy {799 fail!(Error::<T>::NoPermission);800 }801802 <AddressTokens<T>>::remove_prefix(collection_id);803 <Allowances<T>>::remove_prefix(collection_id);804 <Balance<T>>::remove_prefix(collection_id);805 <ItemListIndex>::remove(collection_id);806 <AdminList<T>>::remove(collection_id);807 <CollectionById<T>>::remove(collection_id);808 <WhiteList<T>>::remove_prefix(collection_id);809810 <NftItemList<T>>::remove_prefix(collection_id);811 <FungibleItemList<T>>::remove_prefix(collection_id);812 <ReFungibleItemList<T>>::remove_prefix(collection_id);813814 <NftTransferBasket<T>>::remove_prefix(collection_id);815 <FungibleTransferBasket<T>>::remove_prefix(collection_id);816 <ReFungibleTransferBasket<T>>::remove_prefix(collection_id);817818 <VariableMetaDataBasket<T>>::remove_prefix(collection_id);819820 DestroyedCollectionCount::put(DestroyedCollectionCount::get()821 .checked_add(1)822 .ok_or(Error::<T>::NumOverflow)?);823824 Ok(())825 }826827 /// Add an address to white list.828 /// 829 /// # Permissions830 /// 831 /// * Collection Owner832 /// * Collection Admin833 /// 834 /// # Arguments835 /// 836 /// * collection_id.837 /// 838 /// * address.839 #[weight = <T as Config>::WeightInfo::add_to_white_list()]840 #[transactional]841 pub fn add_to_white_list(origin, collection_id: CollectionId, address: T::AccountId) -> DispatchResult{842843 let sender = ensure_signed(origin)?;844 let collection = Self::get_collection(collection_id)?;845 Self::check_owner_or_admin_permissions(&collection, sender)?;846847 <WhiteList<T>>::insert(collection_id, address, true);848 849 Ok(())850 }851852 /// Remove an address from white list.853 /// 854 /// # Permissions855 /// 856 /// * Collection Owner857 /// * Collection Admin858 /// 859 /// # Arguments860 /// 861 /// * collection_id.862 /// 863 /// * address.864 #[weight = <T as Config>::WeightInfo::remove_from_white_list()]865 #[transactional]866 pub fn remove_from_white_list(origin, collection_id: CollectionId, address: T::AccountId) -> DispatchResult{867868 let sender = ensure_signed(origin)?;869 let collection = Self::get_collection(collection_id)?;870 Self::check_owner_or_admin_permissions(&collection, sender)?;871872 <WhiteList<T>>::remove(collection_id, address);873874 Ok(())875 }876877 /// Toggle between normal and white list access for the methods with access for `Anyone`.878 /// 879 /// # Permissions880 /// 881 /// * Collection Owner.882 /// 883 /// # Arguments884 /// 885 /// * collection_id.886 /// 887 /// * mode: [AccessMode]888 #[weight = <T as Config>::WeightInfo::set_public_access_mode()]889 #[transactional]890 pub fn set_public_access_mode(origin, collection_id: CollectionId, mode: AccessMode) -> DispatchResult891 {892 let sender = ensure_signed(origin)?;893894 let mut target_collection = Self::get_collection(collection_id)?;895 Self::check_owner_permissions(&target_collection, sender)?;896 target_collection.access = mode;897 Self::save_collection(target_collection);898899 Ok(())900 }901902 /// Allows Anyone to create tokens if:903 /// * White List is enabled, and904 /// * Address is added to white list, and905 /// * This method was called with True parameter906 /// 907 /// # Permissions908 /// * Collection Owner909 ///910 /// # Arguments911 /// 912 /// * collection_id.913 /// 914 /// * mint_permission: Boolean parameter. If True, allows minting to Anyone with conditions above.915 #[weight = <T as Config>::WeightInfo::set_mint_permission()]916 #[transactional]917 pub fn set_mint_permission(origin, collection_id: CollectionId, mint_permission: bool) -> DispatchResult918 {919 let sender = ensure_signed(origin)?;920921 let mut target_collection = Self::get_collection(collection_id)?;922 Self::check_owner_permissions(&target_collection, sender)?;923 target_collection.mint_mode = mint_permission;924 Self::save_collection(target_collection);925926 Ok(())927 }928929 /// Change the owner of the collection.930 /// 931 /// # Permissions932 /// 933 /// * Collection Owner.934 /// 935 /// # Arguments936 /// 937 /// * collection_id.938 /// 939 /// * new_owner.940 #[weight = <T as Config>::WeightInfo::change_collection_owner()]941 #[transactional]942 pub fn change_collection_owner(origin, collection_id: CollectionId, new_owner: T::AccountId) -> DispatchResult {943944 let sender = ensure_signed(origin)?;945 let mut target_collection = Self::get_collection(collection_id)?;946 Self::check_owner_permissions(&target_collection, sender)?;947 target_collection.owner = new_owner;948 Self::save_collection(target_collection);949950 Ok(())951 }952953 /// Adds an admin of the Collection.954 /// 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. 955 /// 956 /// # Permissions957 /// 958 /// * Collection Owner.959 /// * Collection Admin.960 /// 961 /// # Arguments962 /// 963 /// * collection_id: ID of the Collection to add admin for.964 /// 965 /// * new_admin_id: Address of new admin to add.966 #[weight = <T as Config>::WeightInfo::add_collection_admin()]967 #[transactional]968 pub fn add_collection_admin(origin, collection_id: CollectionId, new_admin_id: T::AccountId) -> DispatchResult {969970 let sender = ensure_signed(origin)?;971 let collection = Self::get_collection(collection_id)?;972 Self::check_owner_or_admin_permissions(&collection, sender)?;973 let mut admin_arr = <AdminList<T>>::get(collection_id);974975 match admin_arr.binary_search(&new_admin_id) {976 Ok(_) => {},977 Err(idx) => {978 let limits = ChainLimit::get();979 ensure!(admin_arr.len() < limits.collections_admins_limit as usize, Error::<T>::CollectionAdminsLimitExceeded);980 admin_arr.insert(idx, new_admin_id);981 <AdminList<T>>::insert(collection_id, admin_arr);982 }983 }984 Ok(())985 }986987 /// 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.988 ///989 /// # Permissions990 /// 991 /// * Collection Owner.992 /// * Collection Admin.993 /// 994 /// # Arguments995 /// 996 /// * collection_id: ID of the Collection to remove admin for.997 /// 998 /// * account_id: Address of admin to remove.999 #[weight = <T as Config>::WeightInfo::remove_collection_admin()]1000 #[transactional]1001 pub fn remove_collection_admin(origin, collection_id: CollectionId, account_id: T::AccountId) -> DispatchResult {10021003 let sender = ensure_signed(origin)?;1004 let collection = Self::get_collection(collection_id)?;1005 Self::check_owner_or_admin_permissions(&collection, sender)?;1006 let mut admin_arr = <AdminList<T>>::get(collection_id);10071008 match admin_arr.binary_search(&account_id) {1009 Ok(idx) => {1010 admin_arr.remove(idx);1011 <AdminList<T>>::insert(collection_id, admin_arr);1012 },1013 Err(_) => {}1014 }1015 Ok(())1016 }10171018 /// # Permissions1019 /// 1020 /// * Collection Owner1021 /// 1022 /// # Arguments1023 /// 1024 /// * collection_id.1025 /// 1026 /// * new_sponsor.1027 #[weight = <T as Config>::WeightInfo::set_collection_sponsor()]1028 #[transactional]1029 pub fn set_collection_sponsor(origin, collection_id: CollectionId, new_sponsor: T::AccountId) -> DispatchResult {10301031 let sender = ensure_signed(origin)?;1032 let mut target_collection = Self::get_collection(collection_id)?;1033 Self::check_owner_permissions(&target_collection, sender)?;10341035 target_collection.sponsorship = SponsorshipState::Unconfirmed(new_sponsor);1036 Self::save_collection(target_collection);10371038 Ok(())1039 }10401041 /// # Permissions1042 /// 1043 /// * Sponsor.1044 /// 1045 /// # Arguments1046 /// 1047 /// * collection_id.1048 #[weight = <T as Config>::WeightInfo::confirm_sponsorship()]1049 #[transactional]1050 pub fn confirm_sponsorship(origin, collection_id: CollectionId) -> DispatchResult {10511052 let sender = ensure_signed(origin)?;10531054 let mut target_collection = Self::get_collection(collection_id)?;1055 ensure!(1056 target_collection.sponsorship.pending_sponsor() == Some(&sender),1057 Error::<T>::ConfirmUnsetSponsorFail1058 );10591060 target_collection.sponsorship = SponsorshipState::Confirmed(sender);1061 Self::save_collection(target_collection);10621063 Ok(())1064 }10651066 /// Switch back to pay-per-own-transaction model.1067 ///1068 /// # Permissions1069 ///1070 /// * Collection owner.1071 /// 1072 /// # Arguments1073 /// 1074 /// * collection_id.1075 #[weight = <T as Config>::WeightInfo::remove_collection_sponsor()]1076 #[transactional]1077 pub fn remove_collection_sponsor(origin, collection_id: CollectionId) -> DispatchResult {10781079 let sender = ensure_signed(origin)?;10801081 let mut target_collection = Self::get_collection(collection_id)?;1082 Self::check_owner_permissions(&target_collection, sender)?;10831084 target_collection.sponsorship = SponsorshipState::Disabled;1085 Self::save_collection(target_collection);10861087 Ok(())1088 }10891090 /// This method creates a concrete instance of NFT Collection created with CreateCollection method.1091 /// 1092 /// # Permissions1093 /// 1094 /// * Collection Owner.1095 /// * Collection Admin.1096 /// * Anyone if1097 /// * White List is enabled, and1098 /// * Address is added to white list, and1099 /// * MintPermission is enabled (see SetMintPermission method)1100 /// 1101 /// # Arguments1102 /// 1103 /// * collection_id: ID of the collection.1104 /// 1105 /// * owner: Address, initial owner of the NFT.1106 ///1107 /// * data: Token data to store on chain.1108 // #[weight =1109 // (130_000_000 as Weight)1110 // .saturating_add((2135 as Weight).saturating_mul((properties.len() as u64) as Weight))1111 // .saturating_add(RocksDbWeight::get().reads(10 as Weight))1112 // .saturating_add(RocksDbWeight::get().writes(8 as Weight))]11131114 #[weight = <T as Config>::WeightInfo::create_item(data.len())]1115 #[transactional]1116 pub fn create_item(origin, collection_id: CollectionId, owner: T::AccountId, data: CreateItemData) -> DispatchResult {11171118 let sender = ensure_signed(origin)?;11191120 let target_collection = Self::get_collection(collection_id)?;11211122 Self::can_create_items_in_collection(&target_collection, &sender, &owner, 1)?;1123 Self::validate_create_item_args(&target_collection, &data)?;1124 Self::create_item_no_validation(&target_collection, owner, data)?;11251126 Ok(())1127 }11281129 /// This method creates multiple items in a collection created with CreateCollection method.1130 /// 1131 /// # Permissions1132 /// 1133 /// * Collection Owner.1134 /// * Collection Admin.1135 /// * Anyone if1136 /// * White List is enabled, and1137 /// * Address is added to white list, and1138 /// * MintPermission is enabled (see SetMintPermission method)1139 /// 1140 /// # Arguments1141 /// 1142 /// * collection_id: ID of the collection.1143 /// 1144 /// * itemsData: Array items properties. Each property is an array of bytes itself, see [create_item].1145 /// 1146 /// * owner: Address, initial owner of the NFT.1147 #[weight = <T as Config>::WeightInfo::create_item(items_data.into_iter()1148 .map(|data| { data.len() })1149 .sum())]1150 #[transactional]1151 pub fn create_multiple_items(origin, collection_id: CollectionId, owner: T::AccountId, items_data: Vec<CreateItemData>) -> DispatchResult {11521153 ensure!(items_data.len() > 0, Error::<T>::EmptyArgument);1154 let sender = ensure_signed(origin)?;11551156 let target_collection = Self::get_collection(collection_id)?;11571158 Self::can_create_items_in_collection(&target_collection, &sender, &owner, items_data.len() as u32)?;11591160 for data in &items_data {1161 Self::validate_create_item_args(&target_collection, data)?;1162 }1163 for data in &items_data {1164 Self::create_item_no_validation(&target_collection, owner.clone(), data.clone())?;1165 }11661167 Ok(())1168 }11691170 /// Destroys a concrete instance of NFT.1171 /// 1172 /// # Permissions1173 /// 1174 /// * Collection Owner.1175 /// * Collection Admin.1176 /// * Current NFT Owner.1177 /// 1178 /// # Arguments1179 /// 1180 /// * collection_id: ID of the collection.1181 /// 1182 /// * item_id: ID of NFT to burn.1183 #[weight = <T as Config>::WeightInfo::burn_item()]1184 #[transactional]1185 pub fn burn_item(origin, collection_id: CollectionId, item_id: TokenId, value: u128) -> DispatchResult {11861187 let sender = ensure_signed(origin)?;11881189 // Transfer permissions check1190 let target_collection = Self::get_collection(collection_id)?;1191 ensure!(1192 Self::is_item_owner(sender.clone(), &target_collection, item_id) ||1193 (1194 target_collection.limits.owner_can_transfer &&1195 Self::is_owner_or_admin_permissions(&target_collection, sender.clone())1196 ),1197 Error::<T>::NoPermission1198 );11991200 if target_collection.access == AccessMode::WhiteList {1201 Self::check_white_list(&target_collection, &sender)?;1202 }12031204 match target_collection.mode1205 {1206 CollectionMode::NFT => Self::burn_nft_item(&target_collection, item_id)?,1207 CollectionMode::Fungible(_) => Self::burn_fungible_item(&sender, &target_collection, value)?,1208 CollectionMode::ReFungible => Self::burn_refungible_item(&target_collection, item_id, &sender)?,1209 _ => ()1210 };12111212 // call event1213 Self::deposit_event(RawEvent::ItemDestroyed(target_collection.id, item_id));12141215 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::AccountId, collection_id: CollectionId, item_id: TokenId, value: u128) -> DispatchResult {1244 let sender = ensure_signed(origin)?;1245 let collection = Self::get_collection(collection_id)?;12461247 Self::transfer_internal(sender, recipient, &collection, item_id, value)1248 }12491250 /// Set, change, or remove approved address to transfer the ownership of the NFT.1251 /// 1252 /// # Permissions1253 /// 1254 /// * Collection Owner1255 /// * Collection Admin1256 /// * Current NFT owner1257 /// 1258 /// # Arguments1259 /// 1260 /// * approved: Address that is approved to transfer this NFT or zero (if needed to remove approval).1261 /// 1262 /// * collection_id.1263 /// 1264 /// * item_id: ID of the item.1265 #[weight = <T as Config>::WeightInfo::approve()]1266 #[transactional]1267 pub fn approve(origin, spender: T::AccountId, collection_id: CollectionId, item_id: TokenId, amount: u128) -> DispatchResult {12681269 let sender = ensure_signed(origin)?;1270 let target_collection = Self::get_collection(collection_id)?;12711272 Self::token_exists(&target_collection, item_id)?;12731274 // Transfer permissions check1275 let bypasses_limits = target_collection.limits.owner_can_transfer &&1276 Self::is_owner_or_admin_permissions(1277 &target_collection,1278 sender.clone(),1279 );12801281 let allowance_limit = if bypasses_limits {1282 None1283 } else if let Some(amount) = Self::owned_amount(1284 sender.clone(),1285 &target_collection,1286 item_id,1287 ) {1288 Some(amount)1289 } else {1290 fail!(Error::<T>::NoPermission);1291 };12921293 if target_collection.access == AccessMode::WhiteList {1294 Self::check_white_list(&target_collection, &sender)?;1295 Self::check_white_list(&target_collection, &spender)?;1296 }12971298 let allowance: u128 = amount1299 .checked_add(<Allowances<T>>::get(collection_id, (item_id, &sender, &spender)))1300 .ok_or(Error::<T>::NumOverflow)?;1301 if let Some(limit) = allowance_limit {1302 ensure!(limit >= allowance, Error::<T>::TokenValueTooLow);1303 }1304 <Allowances<T>>::insert(collection_id, (item_id, sender.clone(), spender.clone()), allowance);13051306 Self::deposit_event(RawEvent::Approved(target_collection.id, item_id, sender, spender, allowance));1307 Ok(())1308 }1309 1310 /// 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.1311 /// 1312 /// # Permissions1313 /// * Collection Owner1314 /// * Collection Admin1315 /// * Current NFT owner1316 /// * Address approved by current NFT owner1317 /// 1318 /// # Arguments1319 /// 1320 /// * from: Address that owns token.1321 /// 1322 /// * recipient: Address of token recipient.1323 /// 1324 /// * collection_id.1325 /// 1326 /// * item_id: ID of the item.1327 /// 1328 /// * value: Amount to transfer.1329 #[weight = <T as Config>::WeightInfo::transfer_from()]1330 #[transactional]1331 pub fn transfer_from(origin, from: T::AccountId, recipient: T::AccountId, collection_id: CollectionId, item_id: TokenId, value: u128 ) -> DispatchResult {13321333 let sender = ensure_signed(origin)?;1334 let target_collection = Self::get_collection(collection_id)?;13351336 // Check approval1337 let approval: u128 = <Allowances<T>>::get(collection_id, (item_id, &from, &sender));13381339 // Limits check1340 Self::is_correct_transfer(&target_collection, &recipient)?;13411342 // Transfer permissions check 1343 ensure!(1344 approval >= value || 1345 (1346 target_collection.limits.owner_can_transfer &&1347 Self::is_owner_or_admin_permissions(&target_collection, sender.clone())1348 ),1349 Error::<T>::NoPermission1350 );13511352 if target_collection.access == AccessMode::WhiteList {1353 Self::check_white_list(&target_collection, &sender)?;1354 Self::check_white_list(&target_collection, &recipient)?;1355 }13561357 // Reduce approval by transferred amount or remove if remaining approval drops to 01358 if approval.saturating_sub(value) > 0 {1359 <Allowances<T>>::insert(collection_id, (item_id, &from, &sender), approval - value);1360 }1361 else {1362 <Allowances<T>>::remove(collection_id, (item_id, &from, &sender));1363 }13641365 match target_collection.mode1366 {1367 CollectionMode::NFT => Self::transfer_nft(&target_collection, item_id, from.clone(), recipient.clone())?,1368 CollectionMode::Fungible(_) => Self::transfer_fungible(&target_collection, value, &from, &recipient)?,1369 CollectionMode::ReFungible => Self::transfer_refungible(&target_collection, item_id, value, from.clone(), recipient.clone())?,1370 _ => ()1371 };13721373 Self::deposit_event(RawEvent::Transfer(target_collection.id, item_id, from, recipient, value));1374 Ok(())1375 }13761377 // #[weight = 0]1378 // pub fn safe_transfer_from(origin, collection_id: CollectionId, item_id: TokenId, new_owner: T::AccountId) -> DispatchResult {13791380 // // let no_perm_mes = "You do not have permissions to modify this collection";1381 // // ensure!(<ApprovedList<T>>::contains_key((collection_id, item_id)), no_perm_mes);1382 // // let list_itm = <ApprovedList<T>>::get((collection_id, item_id));1383 // // ensure!(list_itm.contains(&new_owner.clone()), no_perm_mes);13841385 // // // on_nft_received call13861387 // // Self::transfer(origin, collection_id, item_id, new_owner)?;13881389 // Ok(())1390 // }13911392 /// Set off-chain data schema.1393 /// 1394 /// # Permissions1395 /// 1396 /// * Collection Owner1397 /// * Collection Admin1398 /// 1399 /// # Arguments1400 /// 1401 /// * collection_id.1402 /// 1403 /// * schema: String representing the offchain data schema.1404 #[weight = <T as Config>::WeightInfo::set_variable_meta_data()]1405 #[transactional]1406 pub fn set_variable_meta_data (1407 origin,1408 collection_id: CollectionId,1409 item_id: TokenId,1410 data: Vec<u8>1411 ) -> DispatchResult {1412 let sender = ensure_signed(origin)?;1413 1414 let target_collection = Self::get_collection(collection_id)?;1415 Self::token_exists(&target_collection, item_id)?;14161417 ensure!(ChainLimit::get().custom_data_limit >= data.len() as u32, Error::<T>::TokenVariableDataLimitExceeded);14181419 // Modify permissions check1420 ensure!(Self::is_item_owner(sender.clone(), &target_collection, item_id) ||1421 Self::is_owner_or_admin_permissions(&target_collection, sender.clone()),1422 Error::<T>::NoPermission);14231424 match target_collection.mode1425 {1426 CollectionMode::NFT => Self::set_nft_variable_data(&target_collection, item_id, data)?,1427 CollectionMode::ReFungible => Self::set_re_fungible_variable_data(&target_collection, item_id, data)?,1428 CollectionMode::Fungible(_) => fail!(Error::<T>::CantStoreMetadataInFungibleTokens),1429 _ => fail!(Error::<T>::UnexpectedCollectionType)1430 };14311432 Ok(())1433 }1434 1435 /// Set schema standard1436 /// ImageURL1437 /// Unique1438 /// 1439 /// # Permissions1440 /// 1441 /// * Collection Owner1442 /// * Collection Admin1443 /// 1444 /// # Arguments1445 /// 1446 /// * collection_id.1447 /// 1448 /// * schema: SchemaVersion: enum1449 #[weight = <T as Config>::WeightInfo::set_schema_version()]1450 #[transactional]1451 pub fn set_schema_version(1452 origin,1453 collection_id: CollectionId,1454 version: SchemaVersion1455 ) -> DispatchResult {1456 let sender = ensure_signed(origin)?;1457 let mut target_collection = Self::get_collection(collection_id)?;1458 Self::check_owner_or_admin_permissions(&target_collection, sender.clone())?;1459 target_collection.schema_version = version;1460 Self::save_collection(target_collection);14611462 Ok(())1463 }14641465 /// Set off-chain data schema.1466 /// 1467 /// # Permissions1468 /// 1469 /// * Collection Owner1470 /// * Collection Admin1471 /// 1472 /// # Arguments1473 /// 1474 /// * collection_id.1475 /// 1476 /// * schema: String representing the offchain data schema.1477 #[weight = <T as Config>::WeightInfo::set_offchain_schema()]1478 #[transactional]1479 pub fn set_offchain_schema(1480 origin,1481 collection_id: CollectionId,1482 schema: Vec<u8>1483 ) -> DispatchResult {1484 let sender = ensure_signed(origin)?;1485 let mut target_collection = Self::get_collection(collection_id)?;1486 Self::check_owner_or_admin_permissions(&target_collection, sender.clone())?;14871488 // check schema limit1489 ensure!(schema.len() as u32 <= ChainLimit::get().offchain_schema_limit, "");14901491 target_collection.offchain_schema = schema;1492 Self::save_collection(target_collection);14931494 Ok(())1495 }14961497 /// Set const on-chain data schema.1498 /// 1499 /// # Permissions1500 /// 1501 /// * Collection Owner1502 /// * Collection Admin1503 /// 1504 /// # Arguments1505 /// 1506 /// * collection_id.1507 /// 1508 /// * schema: String representing the const on-chain data schema.1509 #[weight = <T as Config>::WeightInfo::set_const_on_chain_schema()]1510 #[transactional]1511 pub fn set_const_on_chain_schema (1512 origin,1513 collection_id: CollectionId,1514 schema: Vec<u8>1515 ) -> DispatchResult {1516 let sender = ensure_signed(origin)?;1517 let mut target_collection = Self::get_collection(collection_id)?;1518 Self::check_owner_or_admin_permissions(&target_collection, sender.clone())?;15191520 // check schema limit1521 ensure!(schema.len() as u32 <= ChainLimit::get().const_on_chain_schema_limit, "");15221523 target_collection.const_on_chain_schema = schema;1524 Self::save_collection(target_collection);15251526 Ok(())1527 }15281529 /// Set variable on-chain data schema.1530 /// 1531 /// # Permissions1532 /// 1533 /// * Collection Owner1534 /// * Collection Admin1535 /// 1536 /// # Arguments1537 /// 1538 /// * collection_id.1539 /// 1540 /// * schema: String representing the variable on-chain data schema.1541 #[weight = <T as Config>::WeightInfo::set_const_on_chain_schema()]1542 #[transactional]1543 pub fn set_variable_on_chain_schema (1544 origin,1545 collection_id: CollectionId,1546 schema: Vec<u8>1547 ) -> DispatchResult {1548 let sender = ensure_signed(origin)?;1549 let mut target_collection = Self::get_collection(collection_id)?;1550 Self::check_owner_or_admin_permissions(&target_collection, sender.clone())?;15511552 // check schema limit1553 ensure!(schema.len() as u32 <= ChainLimit::get().variable_on_chain_schema_limit, "");15541555 target_collection.variable_on_chain_schema = schema;1556 Self::save_collection(target_collection);15571558 Ok(())1559 }15601561 // Sudo permissions function1562 #[weight = <T as Config>::WeightInfo::set_chain_limits()]1563 #[transactional]1564 pub fn set_chain_limits(1565 origin,1566 limits: ChainLimits1567 ) -> DispatchResult {15681569 #[cfg(not(feature = "runtime-benchmarks"))]1570 ensure_root(origin)?;15711572 <ChainLimit>::put(limits);1573 Ok(())1574 }15751576 /// Enable smart contract self-sponsoring.1577 /// 1578 /// # Permissions1579 /// 1580 /// * Contract Owner1581 /// 1582 /// # Arguments1583 /// 1584 /// * contract address1585 /// * enable flag1586 /// 1587 #[weight = <T as Config>::WeightInfo::enable_contract_sponsoring()]1588 #[transactional]1589 pub fn enable_contract_sponsoring(1590 origin,1591 contract_address: T::AccountId,1592 enable: bool1593 ) -> DispatchResult {15941595 let sender = ensure_signed(origin)?;15961597 #[cfg(feature = "runtime-benchmarks")]1598 <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());15991600 Self::ensure_contract_owned(sender, &contract_address)?;16011602 <ContractSelfSponsoring<T>>::insert(contract_address, enable);1603 Ok(())1604 }16051606 /// Set the rate limit for contract sponsoring to specified number of blocks.1607 /// 1608 /// If not set (has the default value of 0 blocks), the sponsoring will be disabled. 1609 /// If set to the number B (for blocks), the transactions will be sponsored with a rate 1610 /// limit of B, i.e. fees for every transaction sent to this smart contract will be paid 1611 /// from contract endowment if there are at least B blocks between such transactions. 1612 /// Nonetheless, if transactions are sent more frequently, the fees are paid by the sender.1613 /// 1614 /// # Permissions1615 /// 1616 /// * Contract Owner1617 /// 1618 /// # Arguments1619 /// 1620 /// -`contract_address`: Address of the contract to sponsor1621 /// -`rate_limit`: Number of blocks to wait until the next sponsored transaction is allowed1622 /// 1623 #[weight = <T as Config>::WeightInfo::set_contract_sponsoring_rate_limit()]1624 #[transactional]1625 pub fn set_contract_sponsoring_rate_limit(1626 origin,1627 contract_address: T::AccountId,1628 rate_limit: T::BlockNumber1629 ) -> DispatchResult {1630 let sender = ensure_signed(origin)?;16311632 #[cfg(feature = "runtime-benchmarks")]1633 <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());16341635 Self::ensure_contract_owned(sender, &contract_address)?;1636 <ContractSponsoringRateLimit<T>>::insert(contract_address, rate_limit);1637 Ok(())1638 }16391640 /// Enable the white list for a contract. Only addresses added to the white list with addToContractWhiteList will be able to call this smart contract.1641 /// 1642 /// # Permissions1643 /// 1644 /// * Address that deployed smart contract.1645 /// 1646 /// # Arguments1647 /// 1648 /// -`contract_address`: Address of the contract.1649 /// 1650 /// - `enable`: . 1651 #[weight = <T as Config>::WeightInfo::toggle_contract_white_list()]1652 #[transactional]1653 pub fn toggle_contract_white_list(1654 origin,1655 contract_address: T::AccountId,1656 enable: bool1657 ) -> DispatchResult {1658 let sender = ensure_signed(origin)?;16591660 #[cfg(feature = "runtime-benchmarks")]1661 <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());16621663 Self::ensure_contract_owned(sender, &contract_address)?;1664 if enable {1665 <ContractWhiteListEnabled<T>>::insert(contract_address, true);1666 } else {1667 <ContractWhiteListEnabled<T>>::remove(contract_address);1668 }1669 Ok(())1670 }1671 1672 /// Add an address to smart contract white list.1673 /// 1674 /// # Permissions1675 /// 1676 /// * Address that deployed smart contract.1677 /// 1678 /// # Arguments1679 /// 1680 /// -`contract_address`: Address of the contract.1681 ///1682 /// -`account_address`: Address to add.1683 #[weight = <T as Config>::WeightInfo::add_to_contract_white_list()]1684 #[transactional]1685 pub fn add_to_contract_white_list(1686 origin,1687 contract_address: T::AccountId,1688 account_address: T::AccountId1689 ) -> DispatchResult {1690 let sender = ensure_signed(origin)?;16911692 #[cfg(feature = "runtime-benchmarks")]1693 <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());1694 1695 Self::ensure_contract_owned(sender, &contract_address)?; 1696 <ContractWhiteList<T>>::insert(contract_address, account_address, true);1697 Ok(())1698 }16991700 /// Remove an address from smart contract white list.1701 /// 1702 /// # Permissions1703 /// 1704 /// * Address that deployed smart contract.1705 /// 1706 /// # Arguments1707 /// 1708 /// -`contract_address`: Address of the contract.1709 ///1710 /// -`account_address`: Address to remove.1711 #[weight = <T as Config>::WeightInfo::remove_from_contract_white_list()]1712 #[transactional]1713 pub fn remove_from_contract_white_list(1714 origin,1715 contract_address: T::AccountId,1716 account_address: T::AccountId1717 ) -> DispatchResult {1718 let sender = ensure_signed(origin)?;17191720 #[cfg(feature = "runtime-benchmarks")]1721 <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());17221723 Self::ensure_contract_owned(sender, &contract_address)?;1724 <ContractWhiteList<T>>::remove(contract_address, account_address);1725 Ok(())1726 }17271728 #[weight = <T as Config>::WeightInfo::set_collection_limits()]1729 #[transactional]1730 pub fn set_collection_limits(1731 origin,1732 collection_id: u32,1733 new_limits: CollectionLimits<T::BlockNumber>,1734 ) -> DispatchResult {1735 let sender = ensure_signed(origin)?;1736 let mut target_collection = Self::get_collection(collection_id)?;1737 Self::check_owner_permissions(&target_collection, sender.clone())?;1738 let old_limits = &target_collection.limits;1739 let chain_limits = ChainLimit::get();17401741 // collection bounds1742 ensure!(new_limits.sponsor_transfer_timeout <= MAX_SPONSOR_TIMEOUT &&1743 new_limits.account_token_ownership_limit <= MAX_TOKEN_OWNERSHIP && 1744 new_limits.sponsored_data_size <= chain_limits.custom_data_limit,1745 Error::<T>::CollectionLimitBoundsExceeded);17461747 // token_limit check prev1748 ensure!(old_limits.token_limit >= new_limits.token_limit, Error::<T>::CollectionTokenLimitExceeded);1749 ensure!(new_limits.token_limit > 0, Error::<T>::CollectionTokenLimitExceeded);17501751 ensure!(1752 (old_limits.owner_can_transfer || !new_limits.owner_can_transfer) &&1753 (old_limits.owner_can_destroy || !new_limits.owner_can_destroy),1754 Error::<T>::OwnerPermissionsCantBeReverted,1755 );17561757 target_collection.limits = new_limits;1758 Self::save_collection(target_collection);17591760 Ok(())1761 } 1762 }1763}17641765impl<T: Config> Module<T> {17661767 pub fn transfer_internal(sender: T::AccountId, recipient: T::AccountId, target_collection: &CollectionHandle<T>, item_id: TokenId, value: u128) -> DispatchResult {1768 // Limits check1769 Self::is_correct_transfer(target_collection, &recipient)?;17701771 // Transfer permissions check1772 ensure!(Self::is_item_owner(sender.clone(), target_collection, item_id) ||1773 Self::is_owner_or_admin_permissions(target_collection, sender.clone()),1774 Error::<T>::NoPermission);17751776 if target_collection.access == AccessMode::WhiteList {1777 Self::check_white_list(target_collection, &sender)?;1778 Self::check_white_list(target_collection, &recipient)?;1779 }17801781 match target_collection.mode1782 {1783 CollectionMode::NFT => Self::transfer_nft(target_collection, item_id, sender.clone(), recipient.clone())?,1784 CollectionMode::Fungible(_) => Self::transfer_fungible(target_collection, value, &sender, &recipient)?,1785 CollectionMode::ReFungible => Self::transfer_refungible(target_collection, item_id, value, sender.clone(), recipient.clone())?,1786 _ => ()1787 };17881789 Self::deposit_event(RawEvent::Transfer(target_collection.id, item_id, sender, recipient, value));17901791 Ok(())1792 }179317941795 fn is_correct_transfer(collection: &CollectionHandle<T>, recipient: &T::AccountId) -> DispatchResult {1796 let collection_id = collection.id;17971798 // check token limit and account token limit1799 let account_items: u32 = <AddressTokens<T>>::get(collection_id, recipient).len() as u32;1800 ensure!(collection.limits.account_token_ownership_limit > account_items, Error::<T>::AccountTokenLimitExceeded);1801 1802 Ok(())1803 }18041805 fn can_create_items_in_collection(collection: &CollectionHandle<T>, sender: &T::AccountId, owner: &T::AccountId, amount: u32) -> DispatchResult {1806 let collection_id = collection.id;18071808 // check token limit and account token limit1809 let total_items: u32 = ItemListIndex::get(collection_id)1810 .checked_add(amount)1811 .ok_or(Error::<T>::CollectionTokenLimitExceeded)?;1812 let account_items: u32 = (<AddressTokens<T>>::get(collection_id, owner).len() as u32)1813 .checked_add(amount)1814 .ok_or(Error::<T>::AccountTokenLimitExceeded)?;1815 ensure!(collection.limits.token_limit >= total_items, Error::<T>::CollectionTokenLimitExceeded);1816 ensure!(collection.limits.account_token_ownership_limit >= account_items, Error::<T>::AccountTokenLimitExceeded);18171818 if !Self::is_owner_or_admin_permissions(collection, sender.clone()) {1819 ensure!(collection.mint_mode == true, Error::<T>::PublicMintingNotAllowed);1820 Self::check_white_list(collection, owner)?;1821 Self::check_white_list(collection, sender)?;1822 }18231824 Ok(())1825 }18261827 fn validate_create_item_args(target_collection: &CollectionHandle<T>, data: &CreateItemData) -> DispatchResult {1828 match target_collection.mode1829 {1830 CollectionMode::NFT => {1831 if let CreateItemData::NFT(data) = data {1832 // check sizes1833 ensure!(ChainLimit::get().custom_data_limit >= data.const_data.len() as u32, Error::<T>::TokenConstDataLimitExceeded);1834 ensure!(ChainLimit::get().custom_data_limit >= data.variable_data.len() as u32, Error::<T>::TokenVariableDataLimitExceeded);1835 } else {1836 fail!(Error::<T>::NotNftDataUsedToMintNftCollectionToken);1837 }1838 },1839 CollectionMode::Fungible(_) => {1840 if let CreateItemData::Fungible(_) = data {1841 } else {1842 fail!(Error::<T>::NotFungibleDataUsedToMintFungibleCollectionToken);1843 }1844 },1845 CollectionMode::ReFungible => {1846 if let CreateItemData::ReFungible(data) = data {18471848 // check sizes1849 ensure!(ChainLimit::get().custom_data_limit >= data.const_data.len() as u32, Error::<T>::TokenConstDataLimitExceeded);1850 ensure!(ChainLimit::get().custom_data_limit >= data.variable_data.len() as u32, Error::<T>::TokenVariableDataLimitExceeded);18511852 // Check refungibility limits1853 ensure!(data.pieces <= MAX_REFUNGIBLE_PIECES, Error::<T>::WrongRefungiblePieces);1854 ensure!(data.pieces > 0, Error::<T>::WrongRefungiblePieces);1855 } else {1856 fail!(Error::<T>::NotReFungibleDataUsedToMintReFungibleCollectionToken);1857 }1858 },1859 _ => { fail!(Error::<T>::UnexpectedCollectionType); }1860 };18611862 Ok(())1863 }18641865 fn create_item_no_validation(collection: &CollectionHandle<T>, owner: T::AccountId, data: CreateItemData) -> DispatchResult {1866 match data1867 {1868 CreateItemData::NFT(data) => {1869 let item = NftItemType {1870 owner: owner.clone(),1871 const_data: data.const_data,1872 variable_data: data.variable_data1873 };18741875 Self::add_nft_item(collection, item)?;1876 },1877 CreateItemData::Fungible(data) => {1878 Self::add_fungible_item(collection, &owner, data.value)?;1879 },1880 CreateItemData::ReFungible(data) => {1881 let mut owner_list = Vec::new();1882 owner_list.push(Ownership {owner: owner.clone(), fraction: data.pieces});18831884 let item = ReFungibleItemType {1885 owner: owner_list,1886 const_data: data.const_data,1887 variable_data: data.variable_data1888 };18891890 Self::add_refungible_item(collection, item)?;1891 }1892 };18931894 Ok(())1895 }18961897 fn add_fungible_item(collection: &CollectionHandle<T>, owner: &T::AccountId, value: u128) -> DispatchResult {1898 let collection_id = collection.id;18991900 // Does new owner already have an account?1901 let balance: u128 = <FungibleItemList<T>>::get(collection_id, owner).value;19021903 // Mint 1904 let item = FungibleItemType {1905 value: balance.checked_add(value).ok_or(Error::<T>::NumOverflow)?,1906 };1907 <FungibleItemList<T>>::insert(collection_id, (*owner).clone(), item);19081909 // Update balance1910 let new_balance = <Balance<T>>::get(collection_id, owner)1911 .checked_add(value)1912 .ok_or(Error::<T>::NumOverflow)?;1913 <Balance<T>>::insert(collection_id, (*owner).clone(), new_balance);19141915 Self::deposit_event(RawEvent::ItemCreated(collection_id, 0, owner.clone()));1916 Ok(())1917 }19181919 fn add_refungible_item(collection: &CollectionHandle<T>, item: ReFungibleItemType<T::AccountId>) -> DispatchResult {1920 let collection_id = collection.id;19211922 let current_index = <ItemListIndex>::get(collection_id)1923 .checked_add(1)1924 .ok_or(Error::<T>::NumOverflow)?;1925 let itemcopy = item.clone();19261927 ensure!(1928 item.owner.len() == 1,1929 Error::<T>::BadCreateRefungibleCall,1930 );1931 let item_owner = item.owner.first().expect("only one owner is defined");19321933 let value = item_owner.fraction;1934 let owner = item_owner.owner.clone();19351936 Self::add_token_index(collection_id, current_index, &owner)?;19371938 <ItemListIndex>::insert(collection_id, current_index);1939 <ReFungibleItemList<T>>::insert(collection_id, current_index, itemcopy);19401941 // Update balance1942 let new_balance = <Balance<T>>::get(collection_id, &owner)1943 .checked_add(value)1944 .ok_or(Error::<T>::NumOverflow)?;1945 <Balance<T>>::insert(collection_id, owner.clone(), new_balance);19461947 Self::deposit_event(RawEvent::ItemCreated(collection_id, current_index, owner));1948 Ok(())1949 }19501951 fn add_nft_item(collection: &CollectionHandle<T>, item: NftItemType<T::AccountId>) -> DispatchResult {1952 let collection_id = collection.id;19531954 let current_index = <ItemListIndex>::get(collection_id)1955 .checked_add(1)1956 .ok_or(Error::<T>::NumOverflow)?;19571958 let item_owner = item.owner.clone();1959 Self::add_token_index(collection_id, current_index, &item.owner)?;19601961 <ItemListIndex>::insert(collection_id, current_index);1962 <NftItemList<T>>::insert(collection_id, current_index, item);19631964 // Update balance1965 let new_balance = <Balance<T>>::get(collection_id, item_owner.clone())1966 .checked_add(1)1967 .ok_or(Error::<T>::NumOverflow)?;1968 <Balance<T>>::insert(collection_id, item_owner.clone(), new_balance);19691970 Self::deposit_event(RawEvent::ItemCreated(collection_id, current_index, item_owner));1971 Ok(())1972 }19731974 fn burn_refungible_item(1975 collection: &CollectionHandle<T>,1976 item_id: TokenId,1977 owner: &T::AccountId,1978 ) -> DispatchResult {1979 let collection_id = collection.id;19801981 let mut token = <ReFungibleItemList<T>>::get(collection_id, item_id)1982 .ok_or(Error::<T>::TokenNotFound)?;1983 let rft_balance = token1984 .owner1985 .iter()1986 .find(|&i| i.owner == *owner)1987 .ok_or(Error::<T>::TokenNotFound)?;1988 Self::remove_token_index(collection_id, item_id, owner)?;19891990 // update balance1991 let new_balance = <Balance<T>>::get(collection_id, rft_balance.owner.clone())1992 .checked_sub(rft_balance.fraction)1993 .ok_or(Error::<T>::NumOverflow)?;1994 <Balance<T>>::insert(collection_id, rft_balance.owner.clone(), new_balance);19951996 // Re-create owners list with sender removed1997 let index = token1998 .owner1999 .iter()2000 .position(|i| i.owner == *owner)2001 .expect("owned item is exists");2002 token.owner.remove(index);2003 let owner_count = token.owner.len();20042005 // Burn the token completely if this was the last (only) owner2006 if owner_count == 0 {2007 <ReFungibleItemList<T>>::remove(collection_id, item_id);2008 <VariableMetaDataBasket<T>>::remove(collection_id, item_id);2009 }2010 else {2011 <ReFungibleItemList<T>>::insert(collection_id, item_id, token);2012 }20132014 Ok(())2015 }20162017 fn burn_nft_item(collection: &CollectionHandle<T>, item_id: TokenId) -> DispatchResult {2018 let collection_id = collection.id;20192020 let item = <NftItemList<T>>::get(collection_id, item_id)2021 .ok_or(Error::<T>::TokenNotFound)?;2022 Self::remove_token_index(collection_id, item_id, &item.owner)?;20232024 // update balance2025 let new_balance = <Balance<T>>::get(collection_id, &item.owner)2026 .checked_sub(1)2027 .ok_or(Error::<T>::NumOverflow)?;2028 <Balance<T>>::insert(collection_id, item.owner.clone(), new_balance);2029 <NftItemList<T>>::remove(collection_id, item_id);2030 <VariableMetaDataBasket<T>>::remove(collection_id, item_id);20312032 Ok(())2033 }20342035 fn burn_fungible_item(owner: &T::AccountId, collection: &CollectionHandle<T>, value: u128) -> DispatchResult {2036 let collection_id = collection.id;20372038 let mut balance = <FungibleItemList<T>>::get(collection_id, owner);2039 ensure!(balance.value >= value, Error::<T>::TokenValueNotEnough);20402041 // update balance2042 let new_balance = <Balance<T>>::get(collection_id, owner)2043 .checked_sub(value)2044 .ok_or(Error::<T>::NumOverflow)?;2045 <Balance<T>>::insert(collection_id, (*owner).clone(), new_balance);20462047 if balance.value - value > 0 {2048 balance.value -= value;2049 <FungibleItemList<T>>::insert(collection_id, (*owner).clone(), balance);2050 }2051 else {2052 <FungibleItemList<T>>::remove(collection_id, owner);2053 }20542055 Ok(())2056 }20572058 pub fn get_collection(collection_id: CollectionId) -> Result<CollectionHandle<T>, sp_runtime::DispatchError> {2059 Ok(<CollectionById<T>>::get(collection_id)2060 .map(|collection| CollectionHandle {2061 id: collection_id,2062 collection2063 })2064 .ok_or(Error::<T>::CollectionNotFound)?)2065 }20662067 fn save_collection(collection: CollectionHandle<T>) {2068 <CollectionById<T>>::insert(collection.id, collection.collection);2069 }20702071 fn check_owner_permissions(target_collection: &CollectionHandle<T>, subject: T::AccountId) -> DispatchResult {2072 ensure!(2073 subject == target_collection.owner,2074 Error::<T>::NoPermission2075 );20762077 Ok(())2078 }20792080 fn is_owner_or_admin_permissions(collection: &CollectionHandle<T>, subject: T::AccountId) -> bool {2081 subject == collection.owner || <AdminList<T>>::get(collection.id).contains(&subject)2082 }20832084 fn check_owner_or_admin_permissions(2085 collection: &CollectionHandle<T>,2086 subject: T::AccountId,2087 ) -> DispatchResult {2088 ensure!(Self::is_owner_or_admin_permissions(collection, subject), Error::<T>::NoPermission);20892090 Ok(())2091 }20922093 fn owned_amount(2094 subject: T::AccountId,2095 target_collection: &CollectionHandle<T>,2096 item_id: TokenId,2097 ) -> Option<u128> {2098 let collection_id = target_collection.id;20992100 match target_collection.mode {2101 CollectionMode::NFT => (<NftItemList<T>>::get(collection_id, item_id)?.owner == subject)2102 .then(|| 1),2103 CollectionMode::Fungible(_) => Some(<FungibleItemList<T>>::get(collection_id, &subject)2104 .value),2105 CollectionMode::ReFungible => <ReFungibleItemList<T>>::get(collection_id, item_id)?2106 .owner2107 .iter()2108 .find(|i| i.owner == subject)2109 .map(|i| i.fraction),2110 CollectionMode::Invalid => None,2111 }2112 }21132114 fn is_item_owner(subject: T::AccountId, target_collection: &CollectionHandle<T>, item_id: TokenId) -> bool {2115 match target_collection.mode {2116 CollectionMode::Fungible(_) => true,2117 _ => Self::owned_amount(subject, target_collection, item_id).is_some(),2118 }2119 }21202121 fn check_white_list(collection: &CollectionHandle<T>, address: &T::AccountId) -> DispatchResult {2122 let collection_id = collection.id;21232124 let mes = Error::<T>::AddresNotInWhiteList;2125 ensure!(<WhiteList<T>>::contains_key(collection_id, address), mes);21262127 Ok(())2128 }21292130 /// Check if token exists. In case of Fungible, check if there is an entry for 2131 /// the owner in fungible balances double map2132 fn token_exists(2133 target_collection: &CollectionHandle<T>,2134 item_id: TokenId,2135 ) -> DispatchResult {2136 let collection_id = target_collection.id;2137 let exists = match target_collection.mode2138 {2139 CollectionMode::NFT => <NftItemList<T>>::contains_key(collection_id, item_id),2140 CollectionMode::Fungible(_) => true,2141 CollectionMode::ReFungible => <ReFungibleItemList<T>>::contains_key(collection_id, item_id),2142 _ => false2143 };21442145 ensure!(exists == true, Error::<T>::TokenNotFound);2146 Ok(())2147 }21482149 fn transfer_fungible(2150 collection: &CollectionHandle<T>,2151 value: u128,2152 owner: &T::AccountId,2153 recipient: &T::AccountId,2154 ) -> DispatchResult {2155 let collection_id = collection.id;21562157 let mut balance = <FungibleItemList<T>>::get(collection_id, owner);2158 ensure!(balance.value >= value, Error::<T>::TokenValueTooLow);21592160 // Send balance to recipient (updates balanceOf of recipient)2161 Self::add_fungible_item(collection, recipient, value)?;21622163 // update balanceOf of sender2164 <Balance<T>>::insert(collection_id, (*owner).clone(), balance.value - value);21652166 // Reduce or remove sender2167 if balance.value == value {2168 <FungibleItemList<T>>::remove(collection_id, owner);2169 }2170 else {2171 balance.value -= value;2172 <FungibleItemList<T>>::insert(collection_id, (*owner).clone(), balance);2173 }21742175 Ok(())2176 }21772178 fn transfer_refungible(2179 collection: &CollectionHandle<T>,2180 item_id: TokenId,2181 value: u128,2182 owner: T::AccountId,2183 new_owner: T::AccountId,2184 ) -> DispatchResult {2185 let collection_id = collection.id;2186 let full_item = <ReFungibleItemList<T>>::get(collection_id, item_id)2187 .ok_or(Error::<T>::TokenNotFound)?;21882189 let item = full_item2190 .owner2191 .iter()2192 .filter(|i| i.owner == owner)2193 .next()2194 .ok_or(Error::<T>::TokenNotFound)?;2195 let amount = item.fraction;21962197 ensure!(amount >= value, Error::<T>::TokenValueTooLow);21982199 // update balance2200 let balance_old_owner = <Balance<T>>::get(collection_id, item.owner.clone())2201 .checked_sub(value)2202 .ok_or(Error::<T>::NumOverflow)?;2203 <Balance<T>>::insert(collection_id, item.owner.clone(), balance_old_owner);22042205 let balance_new_owner = <Balance<T>>::get(collection_id, new_owner.clone())2206 .checked_add(value)2207 .ok_or(Error::<T>::NumOverflow)?;2208 <Balance<T>>::insert(collection_id, new_owner.clone(), balance_new_owner);22092210 let old_owner = item.owner.clone();2211 let new_owner_has_account = full_item.owner.iter().any(|i| i.owner == new_owner);22122213 // transfer2214 if amount == value && !new_owner_has_account {2215 // change owner2216 // new owner do not have account2217 let mut new_full_item = full_item.clone();2218 new_full_item2219 .owner2220 .iter_mut()2221 .find(|i| i.owner == owner)2222 .expect("old owner does present in refungible")2223 .owner = new_owner.clone();2224 <ReFungibleItemList<T>>::insert(collection_id, item_id, new_full_item);22252226 // update index collection2227 Self::move_token_index(collection_id, item_id, &old_owner, &new_owner)?;2228 } else {2229 let mut new_full_item = full_item.clone();2230 new_full_item2231 .owner2232 .iter_mut()2233 .find(|i| i.owner == owner)2234 .expect("old owner does present in refungible")2235 .fraction -= value;22362237 // separate amount2238 if new_owner_has_account {2239 // new owner has account2240 new_full_item2241 .owner2242 .iter_mut()2243 .find(|i| i.owner == new_owner)2244 .expect("new owner has account")2245 .fraction += value;2246 } else {2247 // new owner do not have account2248 new_full_item.owner.push(Ownership {2249 owner: new_owner.clone(),2250 fraction: value,2251 });2252 Self::add_token_index(collection_id, item_id, &new_owner)?;2253 }22542255 <ReFungibleItemList<T>>::insert(collection_id, item_id, new_full_item);2256 }22572258 Ok(())2259 }22602261 fn transfer_nft(2262 collection: &CollectionHandle<T>,2263 item_id: TokenId,2264 sender: T::AccountId,2265 new_owner: T::AccountId,2266 ) -> DispatchResult {2267 let collection_id = collection.id;2268 let mut item = <NftItemList<T>>::get(collection_id, item_id)2269 .ok_or(Error::<T>::TokenNotFound)?;22702271 ensure!(2272 sender == item.owner,2273 Error::<T>::MustBeTokenOwner2274 );22752276 // update balance2277 let balance_old_owner = <Balance<T>>::get(collection_id, item.owner.clone())2278 .checked_sub(1)2279 .ok_or(Error::<T>::NumOverflow)?;2280 <Balance<T>>::insert(collection_id, item.owner.clone(), balance_old_owner);22812282 let balancenew_owner = <Balance<T>>::get(collection_id, new_owner.clone())2283 .checked_add(1)2284 .ok_or(Error::<T>::NumOverflow)?;2285 <Balance<T>>::insert(collection_id, new_owner.clone(), balancenew_owner);22862287 // change owner2288 let old_owner = item.owner.clone();2289 item.owner = new_owner.clone();2290 <NftItemList<T>>::insert(collection_id, item_id, item);22912292 // update index collection2293 Self::move_token_index(collection_id, item_id, &old_owner, &new_owner)?;22942295 Ok(())2296 }2297 2298 fn set_re_fungible_variable_data(2299 collection: &CollectionHandle<T>,2300 item_id: TokenId,2301 data: Vec<u8>2302 ) -> DispatchResult {2303 let collection_id = collection.id;2304 let mut item = <ReFungibleItemList<T>>::get(collection_id, item_id)2305 .ok_or(Error::<T>::TokenNotFound)?;23062307 item.variable_data = data;23082309 <ReFungibleItemList<T>>::insert(collection_id, item_id, item);23102311 Ok(())2312 }23132314 fn set_nft_variable_data(2315 collection: &CollectionHandle<T>,2316 item_id: TokenId,2317 data: Vec<u8>2318 ) -> DispatchResult {2319 let collection_id = collection.id;2320 let mut item = <NftItemList<T>>::get(collection_id, item_id)2321 .ok_or(Error::<T>::TokenNotFound)?;2322 2323 item.variable_data = data;23242325 <NftItemList<T>>::insert(collection_id, item_id, item);2326 2327 Ok(())2328 }23292330 fn init_collection(item: &Collection<T>) {2331 // check params2332 assert!(2333 item.decimal_points <= MAX_DECIMAL_POINTS,2334 "decimal_points parameter must be lower than MAX_DECIMAL_POINTS"2335 );2336 assert!(2337 item.name.len() <= 64,2338 "Collection name can not be longer than 63 char"2339 );2340 assert!(2341 item.name.len() <= 256,2342 "Collection description can not be longer than 255 char"2343 );2344 assert!(2345 item.token_prefix.len() <= 16,2346 "Token prefix can not be longer than 15 char"2347 );23482349 // Generate next collection ID2350 let next_id = CreatedCollectionCount::get()2351 .checked_add(1)2352 .unwrap();23532354 CreatedCollectionCount::put(next_id);2355 }23562357 fn init_nft_token(collection_id: CollectionId, item: &NftItemType<T::AccountId>) {2358 let current_index = <ItemListIndex>::get(collection_id)2359 .checked_add(1)2360 .unwrap();23612362 let item_owner = item.owner.clone();2363 Self::add_token_index(collection_id, current_index, &item.owner).unwrap();23642365 <ItemListIndex>::insert(collection_id, current_index);23662367 // Update balance2368 let new_balance = <Balance<T>>::get(collection_id, &item_owner)2369 .checked_add(1)2370 .unwrap();2371 <Balance<T>>::insert(collection_id, item_owner.clone(), new_balance);2372 }23732374 fn init_fungible_token(collection_id: CollectionId, owner: &T::AccountId, item: &FungibleItemType) {2375 let current_index = <ItemListIndex>::get(collection_id)2376 .checked_add(1)2377 .unwrap();23782379 Self::add_token_index(collection_id, current_index, owner).unwrap();23802381 <ItemListIndex>::insert(collection_id, current_index);23822383 // Update balance2384 let new_balance = <Balance<T>>::get(collection_id, owner)2385 .checked_add(item.value)2386 .unwrap();2387 <Balance<T>>::insert(collection_id, (*owner).clone(), new_balance);2388 }23892390 fn init_refungible_token(collection_id: CollectionId, item: &ReFungibleItemType<T::AccountId>) {2391 let current_index = <ItemListIndex>::get(collection_id)2392 .checked_add(1)2393 .unwrap();23942395 let value = item.owner.first().unwrap().fraction;2396 let owner = item.owner.first().unwrap().owner.clone();23972398 Self::add_token_index(collection_id, current_index, &owner).unwrap();23992400 <ItemListIndex>::insert(collection_id, current_index);24012402 // Update balance2403 let new_balance = <Balance<T>>::get(collection_id, &owner)2404 .checked_add(value)2405 .unwrap();2406 <Balance<T>>::insert(collection_id, owner.clone(), new_balance);2407 }24082409 fn add_token_index(collection_id: CollectionId, item_index: TokenId, owner: &T::AccountId) -> DispatchResult {2410 // add to account limit2411 if <AccountItemCount<T>>::contains_key(owner) {24122413 // bound Owned tokens by a single address2414 let count = <AccountItemCount<T>>::get(owner);2415 ensure!(count < ChainLimit::get().account_token_ownership_limit, Error::<T>::AddressOwnershipLimitExceeded);24162417 <AccountItemCount<T>>::insert(owner.clone(), count2418 .checked_add(1)2419 .ok_or(Error::<T>::NumOverflow)?);2420 }2421 else {2422 <AccountItemCount<T>>::insert(owner.clone(), 1);2423 }24242425 let list_exists = <AddressTokens<T>>::contains_key(collection_id, owner);2426 if list_exists {2427 let mut list = <AddressTokens<T>>::get(collection_id, owner);2428 let item_contains = list.contains(&item_index.clone());24292430 if !item_contains {2431 list.push(item_index.clone());2432 }24332434 <AddressTokens<T>>::insert(collection_id, owner.clone(), list);2435 } else {2436 let mut itm = Vec::new();2437 itm.push(item_index.clone());2438 <AddressTokens<T>>::insert(collection_id, owner.clone(), itm);2439 }24402441 Ok(())2442 }24432444 fn remove_token_index(2445 collection_id: CollectionId,2446 item_index: TokenId,2447 owner: &T::AccountId,2448 ) -> DispatchResult {24492450 // update counter2451 <AccountItemCount<T>>::insert(owner.clone(), 2452 <AccountItemCount<T>>::get(owner)2453 .checked_sub(1)2454 .ok_or(Error::<T>::NumOverflow)?);245524562457 let list_exists = <AddressTokens<T>>::contains_key(collection_id, owner);2458 if list_exists {2459 let mut list = <AddressTokens<T>>::get(collection_id, owner);2460 let item_contains = list.contains(&item_index.clone());24612462 if item_contains {2463 list.retain(|&item| item != item_index);2464 <AddressTokens<T>>::insert(collection_id, owner.clone(), list);2465 }2466 }24672468 Ok(())2469 }24702471 fn move_token_index(2472 collection_id: CollectionId,2473 item_index: TokenId,2474 old_owner: &T::AccountId,2475 new_owner: &T::AccountId,2476 ) -> DispatchResult {2477 Self::remove_token_index(collection_id, item_index, old_owner)?;2478 Self::add_token_index(collection_id, item_index, new_owner)?;24792480 Ok(())2481 }2482 2483 fn ensure_contract_owned(account: T::AccountId, contract: &T::AccountId) -> DispatchResult {2484 ensure!(<ContractOwner<T>>::get(contract) == Some(account), Error::<T>::NoPermission);24852486 Ok(())2487 }2488}24892490////////////////////////////////////////////////////////////////////////////////////////////////////2491// Economic models2492// #region24932494/// Fee multiplier.2495pub type Multiplier = FixedU128;24962497type BalanceOf<T> = <<T as pallet_transaction_payment::Config>::OnChargeTransaction as pallet_transaction_payment::OnChargeTransaction<T>>::Balance;24982499/// Require the transactor pay for themselves and maybe include a tip to gain additional priority2500/// in the queue.2501#[derive(Encode, Decode, Clone, Eq, PartialEq)]2502pub struct ChargeTransactionPayment<T: Config>(#[codec(compact)] BalanceOf<T>);25032504impl<T: Config + Send + Sync> sp_std::fmt::Debug 2505 for ChargeTransactionPayment<T>2506{2507 #[cfg(feature = "std")]2508 fn fmt(&self, f: &mut sp_std::fmt::Formatter) -> sp_std::fmt::Result {2509 write!(f, "ChargeTransactionPayment<{:?}>", self.0)2510 }2511 #[cfg(not(feature = "std"))]2512 fn fmt(&self, _: &mut sp_std::fmt::Formatter) -> sp_std::fmt::Result {2513 Ok(())2514 }2515}25162517impl<T: Config> ChargeTransactionPayment<T>2518where2519 T::Call: Dispatchable<Info=DispatchInfo, PostInfo=PostDispatchInfo> + IsSubType<Call<T>> + IsSubType<pallet_contracts::Call<T>>,2520 BalanceOf<T>: Send + Sync + From<u64> + FixedPointOperand,2521 T::AccountId: AsRef<[u8]>,2522 T::AccountId: UncheckedFrom<T::Hash>,2523{2524 fn traditional_fee(2525 len: usize,2526 info: &DispatchInfoOf<T::Call>,2527 tip: BalanceOf<T>,2528 ) -> BalanceOf<T>2529 where2530 T::Call: Dispatchable<Info = DispatchInfo>,2531 {2532 <pallet_transaction_payment::Module<T>>::compute_fee(len as u32, info, tip)2533 }25342535 fn get_priority(len: usize, info: &DispatchInfoOf<T::Call>, final_fee: BalanceOf<T>) -> TransactionPriority {2536 let weight_saturation = T::BlockWeights::get().max_block / info.weight.max(1);2537 let max_block_length = *T::BlockLength::get().max.get(DispatchClass::Normal);2538 let len_saturation = max_block_length as u64 / (len as u64).max(1);2539 let coefficient: BalanceOf<T> = weight_saturation2540 .min(len_saturation)2541 .saturated_into::<BalanceOf<T>>();2542 final_fee2543 .saturating_mul(coefficient)2544 .saturated_into::<TransactionPriority>()2545 }25462547 fn withdraw_fee(2548 &self,2549 who: &T::AccountId,2550 call: &T::Call,2551 info: &DispatchInfoOf<T::Call>,2552 len: usize,2553 ) -> Result<2554 (2555 BalanceOf<T>,2556 <<T as pallet_transaction_payment::Config>::OnChargeTransaction as pallet_transaction_payment::OnChargeTransaction<T>>::LiquidityInfo,2557 ),2558 TransactionValidityError,2559 > {2560 let tip = self.0;25612562 let fee = Self::traditional_fee(len, info, tip);25632564 // Only mess with balances if fee is not zero.2565 if fee.is_zero() {2566 return <<T as pallet_transaction_payment::Config>::OnChargeTransaction as pallet_transaction_payment::OnChargeTransaction<T>>::withdraw_fee(who, call, info, fee, tip)2567 .map(|i| (fee, i));2568 }25692570 // Determine who is paying transaction fee based on ecnomic model2571 // Parse call to extract collection ID and access collection sponsor2572 let mut sponsor: Option<T::AccountId> = (|| match IsSubType::<Call<T>>::is_sub_type(call) {2573 Some(Call::create_item(collection_id, _owner, _properties)) => {2574 let collection = <CollectionById<T>>::get(collection_id)?;25752576 // sponsor timeout2577 let block_number = <system::Module<T>>::block_number() as T::BlockNumber;25782579 let limit = collection.limits.sponsor_transfer_timeout;2580 if <CreateItemBasket<T>>::contains_key((collection_id, &who)) {2581 let last_tx_block = <CreateItemBasket<T>>::get((collection_id, &who));2582 let limit_time = last_tx_block + limit.into();2583 if block_number <= limit_time {2584 return None;2585 }2586 }2587 <CreateItemBasket<T>>::insert((collection_id, who.clone()), block_number);25882589 // check free create limit2590 if collection.limits.sponsored_data_size >= (_properties.len() as u32) {2591 collection.sponsorship.sponsor()2592 .cloned()2593 } else {2594 None2595 }2596 }2597 Some(Call::transfer(_new_owner, collection_id, item_id, _value)) => {2598 let collection = <CollectionById<T>>::get(collection_id)?;2599 2600 let mut sponsor_transfer = false;2601 if collection.sponsorship.confirmed() {26022603 let collection_limits = collection.limits;2604 let collection_mode = collection.mode;2605 2606 // sponsor timeout2607 let block_number = <system::Module<T>>::block_number() as T::BlockNumber;2608 sponsor_transfer = match collection_mode {2609 CollectionMode::NFT => {2610 2611 // get correct limit2612 let limit: u32 = if collection_limits.sponsor_transfer_timeout > 0 {2613 collection_limits.sponsor_transfer_timeout2614 } else {2615 ChainLimit::get().nft_sponsor_transfer_timeout2616 };2617 2618 let mut sponsored = true;2619 if <NftTransferBasket<T>>::contains_key(collection_id, item_id) {2620 let last_tx_block = <NftTransferBasket<T>>::get(collection_id, item_id);2621 let limit_time = last_tx_block + limit.into();2622 if block_number <= limit_time {2623 sponsored = false;2624 }2625 }2626 if sponsored {2627 <NftTransferBasket<T>>::insert(collection_id, item_id, block_number);2628 }26292630 sponsored2631 }2632 CollectionMode::Fungible(_) => {2633 2634 // get correct limit2635 let limit: u32 = if collection_limits.sponsor_transfer_timeout > 0 {2636 collection_limits.sponsor_transfer_timeout2637 } else {2638 ChainLimit::get().fungible_sponsor_transfer_timeout2639 };2640 2641 let block_number = <system::Module<T>>::block_number() as T::BlockNumber;2642 let mut sponsored = true;2643 if <FungibleTransferBasket<T>>::contains_key(collection_id, who) {2644 let last_tx_block = <FungibleTransferBasket<T>>::get(collection_id, who);2645 let limit_time = last_tx_block + limit.into();2646 if block_number <= limit_time {2647 sponsored = false;2648 }2649 }2650 if sponsored {2651 <FungibleTransferBasket<T>>::insert(collection_id, who, block_number);2652 }26532654 sponsored2655 }2656 CollectionMode::ReFungible => {2657 2658 // get correct limit2659 let limit: u32 = if collection_limits.sponsor_transfer_timeout > 0 {2660 collection_limits.sponsor_transfer_timeout2661 } else {2662 ChainLimit::get().refungible_sponsor_transfer_timeout2663 };2664 2665 let mut sponsored = true;2666 if <ReFungibleTransferBasket<T>>::contains_key(collection_id, item_id) {2667 let last_tx_block = <ReFungibleTransferBasket<T>>::get(collection_id, item_id);2668 let limit_time = last_tx_block + limit.into();2669 if block_number <= limit_time {2670 sponsored = false;2671 }2672 }2673 if sponsored {2674 <ReFungibleTransferBasket<T>>::insert(collection_id, item_id, block_number);2675 }26762677 sponsored2678 }2679 _ => {2680 false2681 },2682 };2683 }26842685 if !sponsor_transfer {2686 None2687 } else {2688 collection.sponsorship.sponsor()2689 .cloned()2690 }2691 }26922693 Some(Call::set_variable_meta_data(collection_id, item_id, data)) => {2694 let mut sponsor_metadata_changes = false;26952696 let collection = <CollectionById<T>>::get(collection_id)?;26972698 if2699 collection.sponsorship.confirmed() &&2700 // Can't sponsor fungible collection, this tx will be rejected2701 // as invalid2702 !matches!(collection.mode, CollectionMode::Fungible(_)) &&2703 data.len() <= collection.limits.sponsored_data_size as usize2704 {2705 if let Some(rate_limit) = collection.limits.sponsored_data_rate_limit {2706 let block_number = <system::Module<T>>::block_number() as T::BlockNumber;27072708 if <VariableMetaDataBasket<T>>::get(collection_id, item_id)2709 .map(|last_block| block_number - last_block > rate_limit)2710 .unwrap_or(true) 2711 {2712 sponsor_metadata_changes = true;2713 <VariableMetaDataBasket<T>>::insert(collection_id, item_id, block_number);2714 }2715 }2716 }27172718 if !sponsor_metadata_changes {2719 None2720 } else {2721 collection.sponsorship.sponsor().cloned()2722 }2723 }27242725 _ => None,2726 })();27272728 match IsSubType::<pallet_contracts::Call<T>>::is_sub_type(call) {2729 Some(pallet_contracts::Call::call(dest, _value, _gas_limit, _data)) => {27302731 let called_contract: T::AccountId = T::Lookup::lookup((*dest).clone()).unwrap_or(T::AccountId::default());27322733 let owned_contract = <ContractOwner<T>>::get(called_contract.clone()).as_ref() == Some(who);2734 let white_list_enabled = <ContractWhiteListEnabled<T>>::contains_key(called_contract.clone());2735 2736 if !owned_contract && white_list_enabled {2737 if !<ContractWhiteList<T>>::contains_key(called_contract.clone(), who) {2738 return Err(InvalidTransaction::Call.into());2739 }2740 }2741 },2742 _ => {},2743 }27442745 // Sponsor smart contracts2746 sponsor = sponsor.or_else(|| match IsSubType::<pallet_contracts::Call<T>>::is_sub_type(call) {27472748 // On instantiation: set the contract owner2749 Some(pallet_contracts::Call::instantiate(_endowment, _gas_limit, code_hash, _data, salt)) => {27502751 let new_contract_address = <pallet_contracts::Module<T>>::contract_address(2752 &who,2753 code_hash,2754 salt,2755 );2756 <ContractOwner<T>>::insert(new_contract_address.clone(), who.clone());27572758 None2759 },27602761 // On instantiation with code: set the contract owner2762 Some(pallet_contracts::Call::instantiate_with_code(_endowment, _gas_limit, _code, _data, _salt)) => {27632764 let new_contract_address = <pallet_contracts::Module<T>>::contract_address(2765 &who,2766 &T::Hashing::hash(&_code),2767 _salt,2768 );27692770 <ContractOwner<T>>::insert(new_contract_address.clone(), who.clone());27712772 None2773 }27742775 // When the contract is called, check if the sponsoring is enabled and pay fees from contract endowment if it is2776 Some(pallet_contracts::Call::call(dest, _value, _gas_limit, _data)) => {27772778 let called_contract: T::AccountId = T::Lookup::lookup((*dest).clone()).unwrap_or(T::AccountId::default());27792780 let mut sponsor_transfer = false;2781 if <ContractSponsoringRateLimit<T>>::contains_key(called_contract.clone()) {2782 let last_tx_block = <ContractSponsorBasket<T>>::get((&called_contract, &who));2783 let block_number = <system::Module<T>>::block_number() as T::BlockNumber;2784 let rate_limit = <ContractSponsoringRateLimit<T>>::get(&called_contract);2785 let limit_time = last_tx_block + rate_limit;27862787 if block_number >= limit_time {2788 <ContractSponsorBasket<T>>::insert((called_contract.clone(), who.clone()), block_number);2789 sponsor_transfer = true;2790 }2791 } else {2792 sponsor_transfer = false;2793 }2794 2795 if sponsor_transfer {2796 if <ContractSelfSponsoring<T>>::contains_key(called_contract.clone()) {2797 if <ContractSelfSponsoring<T>>::get(called_contract.clone()) {2798 return Some(called_contract);2799 }2800 }2801 }28022803 None2804 },28052806 _ => None,2807 });28082809 let who_pays_fee = sponsor.unwrap_or_else(|| who.clone());28102811 <<T as pallet_transaction_payment::Config>::OnChargeTransaction as pallet_transaction_payment::OnChargeTransaction<T>>::withdraw_fee(&who_pays_fee, call, info, fee, tip)2812 .map(|i| (fee, i))2813 }2814}281528162817impl<T: Config + Send + Sync> SignedExtension2818 for ChargeTransactionPayment<T>2819where2820 BalanceOf<T>: Send + Sync + From<u64> + FixedPointOperand,2821 T::Call: Dispatchable<Info = DispatchInfo, PostInfo = PostDispatchInfo> + IsSubType<Call<T>> + IsSubType<pallet_contracts::Call<T>>,2822 T::AccountId: AsRef<[u8]>,2823 T::AccountId: UncheckedFrom<T::Hash>,2824{2825 const IDENTIFIER: &'static str = "ChargeTransactionPayment";2826 type AccountId = T::AccountId;2827 type Call = T::Call;2828 type AdditionalSigned = ();2829 type Pre = (2830 // tip2831 BalanceOf<T>,2832 // who pays fee2833 Self::AccountId,2834 // imbalance resulting from withdrawing the fee2835 <<T as pallet_transaction_payment::Config>::OnChargeTransaction as pallet_transaction_payment::OnChargeTransaction<T>>::LiquidityInfo,2836 );2837 fn additional_signed(&self) -> sp_std::result::Result<(), TransactionValidityError> {2838 Ok(())2839 }28402841 fn validate(2842 &self,2843 who: &Self::AccountId,2844 call: &Self::Call,2845 info: &DispatchInfoOf<Self::Call>,2846 len: usize,2847 ) -> TransactionValidity {2848 let (fee, _) = self.withdraw_fee(who, call, info, len)?;2849 Ok(ValidTransaction {2850 priority: Self::get_priority(len, info, fee),2851 ..Default::default()2852 })2853 }28542855 fn pre_dispatch(2856 self,2857 who: &Self::AccountId,2858 call: &Self::Call,2859 info: &DispatchInfoOf<Self::Call>,2860 len: usize,2861 ) -> Result<Self::Pre, TransactionValidityError> {2862 let (_fee, imbalance) = self.withdraw_fee(who, call, info, len)?;2863 Ok((self.0, who.clone(), imbalance))2864 }28652866 fn post_dispatch(2867 pre: Self::Pre,2868 info: &DispatchInfoOf<Self::Call>,2869 post_info: &PostDispatchInfoOf<Self::Call>,2870 len: usize,2871 _result: &DispatchResult,2872 ) -> Result<(), TransactionValidityError> {2873 let (tip, who, imbalance) = pre;2874 let actual_fee = pallet_transaction_payment::Module::<T>::compute_actual_fee(2875 len as u32,2876 info,2877 post_info,2878 tip,2879 );2880 <T as pallet_transaction_payment::Config>::OnChargeTransaction::correct_and_deposit_fee(&who, info, post_info, actual_fee, tip, imbalance)?;2881 Ok(())2882 }2883}28842885// #endregion1//2// This file is subject to the terms and conditions defined in3// file 'LICENSE', which is part of this source code package.4//56#![recursion_limit = "1024"]78#![cfg_attr(not(feature = "std"), no_std)]910#[cfg(feature = "std")]11pub use serde::*;1213use core::ops::{Deref, DerefMut};14use codec::{Decode, Encode};15pub use frame_support::{16 construct_runtime, decl_event, decl_module, decl_storage, decl_error,17 dispatch::DispatchResult,18 ensure, fail, parameter_types,19 traits::{20 Currency, ExistenceRequirement, Get, Imbalance, KeyOwnerProofSystem, OnUnbalanced,21 Randomness, IsSubType, WithdrawReasons,22 },23 weights::{24 constants::{BlockExecutionWeight, ExtrinsicBaseWeight, RocksDbWeight, WEIGHT_PER_SECOND},25 DispatchInfo, GetDispatchInfo, IdentityFee, Pays, PostDispatchInfo, Weight,26 WeightToFeePolynomial, DispatchClass,27 },28 StorageValue,29 transactional,30};3132use frame_system::{self as system, ensure_signed, ensure_root};33use sp_core::{H160, H256};34use sp_runtime::sp_std::prelude::Vec;35use sp_runtime::{36 traits::{37 Hash, DispatchInfoOf, Dispatchable, PostDispatchInfoOf, Saturating, SaturatedConversion, SignedExtension, Zero,38 },39 transaction_validity::{40 TransactionPriority, InvalidTransaction, TransactionValidity, TransactionValidityError, ValidTransaction,41 },42 FixedPointOperand, FixedU128,43};44use sp_runtime::traits::StaticLookup;45use pallet_contracts::chain_extension::UncheckedFrom;46use pallet_evm::AddressMapping;47use pallet_transaction_payment::OnChargeTransaction;4849#[cfg(test)]50mod mock;5152#[cfg(test)]53mod tests;5455mod default_weights;56mod eth;5758pub use eth::account::*;5960pub const MAX_DECIMAL_POINTS: DecimalPoints = 30;61pub const MAX_REFUNGIBLE_PIECES: u128 = 1_000_000_000_000_000_000_000;62pub const MAX_SPONSOR_TIMEOUT: u32 = 10_368_000;63pub const MAX_TOKEN_OWNERSHIP: u32 = 10_000_000;6465// Structs66// #region6768pub type CollectionId = u32;69pub type TokenId = u32;70pub type DecimalPoints = u8;7172#[derive(Encode, Decode, Eq, Debug, Clone, PartialEq)]73#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]74pub enum CollectionMode {75 Invalid,76 NFT,77 // decimal points78 Fungible(DecimalPoints),79 ReFungible,80}8182impl Default for CollectionMode {83 fn default() -> Self {84 Self::Invalid85 }86}8788impl Into<u8> for CollectionMode {89 fn into(self) -> u8 {90 match self {91 CollectionMode::Invalid => 0,92 CollectionMode::NFT => 1,93 CollectionMode::Fungible(_) => 2,94 CollectionMode::ReFungible => 3,95 }96 }97}9899#[derive(Encode, Decode, Eq, Debug, Clone, PartialEq)]100#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]101pub enum AccessMode {102 Normal,103 WhiteList,104}105impl Default for AccessMode {106 fn default() -> Self {107 Self::Normal108 }109}110111#[derive(Encode, Decode, Eq, Debug, Clone, PartialEq)]112#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]113pub enum SchemaVersion {114 ImageURL,115 Unique,116}117impl Default for SchemaVersion {118 fn default() -> Self {119 Self::ImageURL120 }121}122123#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]124#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]125pub struct Ownership<AccountId> {126 pub owner: AccountId,127 pub fraction: u128,128}129130#[derive(Encode, Decode, Debug, Clone, PartialEq)]131#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]132pub enum SponsorshipState<AccountId> {133 /// The fees are applied to the transaction sender134 Disabled,135 Unconfirmed(AccountId),136 /// Transactions are sponsored by specified account137 Confirmed(AccountId),138}139140impl<AccountId> SponsorshipState<AccountId> {141 fn sponsor(&self) -> Option<&AccountId> {142 match self {143 Self::Confirmed(sponsor) => Some(sponsor),144 _ => None,145 }146 }147148 fn pending_sponsor(&self) -> Option<&AccountId> {149 match self {150 Self::Unconfirmed(sponsor) | Self::Confirmed(sponsor) => Some(sponsor),151 _ => None,152 }153 }154155 fn confirmed(&self) -> bool {156 matches!(self, Self::Confirmed(_))157 }158}159160impl<T> Default for SponsorshipState<T> {161 fn default() -> Self {162 Self::Disabled163 }164}165166#[derive(Encode, Decode, Clone, PartialEq)]167#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]168pub struct Collection<T: Config> {169 pub owner: T::CrossAccountId,170 pub mode: CollectionMode,171 pub access: AccessMode,172 pub decimal_points: DecimalPoints,173 pub name: Vec<u16>, // 64 include null escape char174 pub description: Vec<u16>, // 256 include null escape char175 pub token_prefix: Vec<u8>, // 16 include null escape char176 pub mint_mode: bool,177 pub offchain_schema: Vec<u8>,178 pub schema_version: SchemaVersion,179 pub sponsorship: SponsorshipState<T::CrossAccountId>,180 pub limits: CollectionLimits<T::BlockNumber>, // Collection private restrictions 181 pub variable_on_chain_schema: Vec<u8>, //182 pub const_on_chain_schema: Vec<u8>, //183}184185pub struct CollectionHandle<T: Config> {186 pub id: CollectionId,187 collection: Collection<T>,188}189190impl<T: Config> Deref for CollectionHandle<T> {191 type Target = Collection<T>;192193 fn deref(&self) -> &Self::Target {194 &self.collection195 }196}197198impl<T: Config> DerefMut for CollectionHandle<T> {199 fn deref_mut(&mut self) -> &mut Self::Target {200 &mut self.collection201 }202}203204#[derive(Encode, Decode, Debug, Clone, PartialEq)]205#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]206pub struct NftItemType<AccountId> {207 pub owner: AccountId,208 pub const_data: Vec<u8>,209 pub variable_data: Vec<u8>,210}211212#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]213#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]214pub struct FungibleItemType {215 pub value: u128,216}217218#[derive(Encode, Decode, Debug, Clone, PartialEq)]219#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]220pub struct ReFungibleItemType<AccountId> {221 pub owner: Vec<Ownership<AccountId>>,222 pub const_data: Vec<u8>,223 pub variable_data: Vec<u8>,224}225226// #[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]227// #[cfg_attr(feature = "std", derive(Serialize, Deserialize))]228// pub struct VestingItem<AccountId, Moment> {229// pub sender: AccountId,230// pub recipient: AccountId,231// pub collection_id: CollectionId,232// pub item_id: TokenId,233// pub amount: u64,234// pub vesting_date: Moment,235// }236237#[derive(Encode, Decode, Debug, Clone, PartialEq)]238#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]239pub struct CollectionLimits<BlockNumber: Encode + Decode> {240 pub account_token_ownership_limit: u32,241 pub sponsored_data_size: u32,242 /// None - setVariableMetadata is not sponsored243 /// Some(v) - setVariableMetadata is sponsored 244 /// if there is v block between txs245 pub sponsored_data_rate_limit: Option<BlockNumber>,246 pub token_limit: u32,247248 // Timeouts for item types in passed blocks249 pub sponsor_transfer_timeout: u32,250 pub owner_can_transfer: bool,251 pub owner_can_destroy: bool,252}253254impl<BlockNumber: Encode + Decode> Default for CollectionLimits<BlockNumber> {255 fn default() -> Self {256 Self { 257 account_token_ownership_limit: 10_000_000, 258 token_limit: u32::max_value(),259 sponsored_data_size: u32::MAX, 260 sponsored_data_rate_limit: None,261 sponsor_transfer_timeout: 14400,262 owner_can_transfer: true,263 owner_can_destroy: true264 }265 }266}267268#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]269#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]270pub struct ChainLimits {271 pub collection_numbers_limit: u32,272 pub account_token_ownership_limit: u32,273 pub collections_admins_limit: u64,274 pub custom_data_limit: u32,275276 // Timeouts for item types in passed blocks277 pub nft_sponsor_transfer_timeout: u32,278 pub fungible_sponsor_transfer_timeout: u32,279 pub refungible_sponsor_transfer_timeout: u32,280281 // Schema limits282 pub offchain_schema_limit: u32,283 pub variable_on_chain_schema_limit: u32,284 pub const_on_chain_schema_limit: u32,285}286287pub trait WeightInfo {288 fn create_collection() -> Weight;289 fn destroy_collection() -> Weight;290 fn add_to_white_list() -> Weight;291 fn remove_from_white_list() -> Weight;292 fn set_public_access_mode() -> Weight;293 fn set_mint_permission() -> Weight;294 fn change_collection_owner() -> Weight;295 fn add_collection_admin() -> Weight;296 fn remove_collection_admin() -> Weight;297 fn set_collection_sponsor() -> Weight;298 fn confirm_sponsorship() -> Weight;299 fn remove_collection_sponsor() -> Weight;300 fn create_item(s: usize) -> Weight;301 fn burn_item() -> Weight;302 fn transfer() -> Weight;303 fn approve() -> Weight;304 fn transfer_from() -> Weight;305 fn set_offchain_schema() -> Weight;306 fn set_const_on_chain_schema() -> Weight;307 fn set_variable_on_chain_schema() -> Weight;308 fn set_variable_meta_data() -> Weight;309 fn enable_contract_sponsoring() -> Weight;310 fn set_schema_version() -> Weight;311 fn set_chain_limits() -> Weight;312 fn set_contract_sponsoring_rate_limit() -> Weight;313 fn set_variable_meta_data_sponsoring_rate_limit() -> Weight;314 fn toggle_contract_white_list() -> Weight;315 fn add_to_contract_white_list() -> Weight;316 fn remove_from_contract_white_list() -> Weight;317 fn set_collection_limits() -> Weight;318}319320#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]321#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]322pub struct CreateNftData {323 pub const_data: Vec<u8>,324 pub variable_data: Vec<u8>,325}326327#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]328#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]329pub struct CreateFungibleData {330 pub value: u128,331}332333#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]334#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]335pub struct CreateReFungibleData {336 pub const_data: Vec<u8>,337 pub variable_data: Vec<u8>,338 pub pieces: u128,339}340341#[derive(Encode, Decode, Debug, Clone, PartialEq)]342#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]343pub enum CreateItemData {344 NFT(CreateNftData),345 Fungible(CreateFungibleData),346 ReFungible(CreateReFungibleData),347}348349impl CreateItemData {350 pub fn len(&self) -> usize {351 let len = match self {352 CreateItemData::NFT(data) => data.variable_data.len() + data.const_data.len(),353 CreateItemData::ReFungible(data) => data.variable_data.len() + data.const_data.len(),354 _ => 0355 };356 357 return len;358 }359}360361impl From<CreateNftData> for CreateItemData {362 fn from(item: CreateNftData) -> Self {363 CreateItemData::NFT(item)364 }365}366367impl From<CreateReFungibleData> for CreateItemData {368 fn from(item: CreateReFungibleData) -> Self {369 CreateItemData::ReFungible(item)370 }371}372373impl From<CreateFungibleData> for CreateItemData {374 fn from(item: CreateFungibleData) -> Self {375 CreateItemData::Fungible(item)376 }377}378379380decl_error! {381 /// Error for non-fungible-token module.382 pub enum Error for Module<T: Config> {383 /// Total collections bound exceeded.384 TotalCollectionsLimitExceeded,385 /// Decimal_points parameter must be lower than MAX_DECIMAL_POINTS constant, currently it is 30.386 CollectionDecimalPointLimitExceeded, 387 /// Collection name can not be longer than 63 char.388 CollectionNameLimitExceeded, 389 /// Collection description can not be longer than 255 char.390 CollectionDescriptionLimitExceeded, 391 /// Token prefix can not be longer than 15 char.392 CollectionTokenPrefixLimitExceeded,393 /// This collection does not exist.394 CollectionNotFound,395 /// Item not exists.396 TokenNotFound,397 /// Admin not found398 AdminNotFound,399 /// Arithmetic calculation overflow.400 NumOverflow, 401 /// Account already has admin role.402 AlreadyAdmin, 403 /// You do not own this collection.404 NoPermission,405 /// This address is not set as sponsor, use setCollectionSponsor first.406 ConfirmUnsetSponsorFail,407 /// Collection is not in mint mode.408 PublicMintingNotAllowed,409 /// Sender parameter and item owner must be equal.410 MustBeTokenOwner,411 /// Item balance not enough.412 TokenValueTooLow,413 /// Size of item is too large.414 NftSizeLimitExceeded,415 /// No approve found416 ApproveNotFound,417 /// Requested value more than approved.418 TokenValueNotEnough,419 /// Only approved addresses can call this method.420 ApproveRequired,421 /// Address is not in white list.422 AddresNotInWhiteList,423 /// Number of collection admins bound exceeded.424 CollectionAdminsLimitExceeded,425 /// Owned tokens by a single address bound exceeded.426 AddressOwnershipLimitExceeded,427 /// Length of items properties must be greater than 0.428 EmptyArgument,429 /// const_data exceeded data limit.430 TokenConstDataLimitExceeded,431 /// variable_data exceeded data limit.432 TokenVariableDataLimitExceeded,433 /// Not NFT item data used to mint in NFT collection.434 NotNftDataUsedToMintNftCollectionToken,435 /// Not Fungible item data used to mint in Fungible collection.436 NotFungibleDataUsedToMintFungibleCollectionToken,437 /// Not Re Fungible item data used to mint in Re Fungible collection.438 NotReFungibleDataUsedToMintReFungibleCollectionToken,439 /// Unexpected collection type.440 UnexpectedCollectionType,441 /// Can't store metadata in fungible tokens.442 CantStoreMetadataInFungibleTokens,443 /// Collection token limit exceeded444 CollectionTokenLimitExceeded,445 /// Account token limit exceeded per collection446 AccountTokenLimitExceeded,447 /// Collection limit bounds per collection exceeded448 CollectionLimitBoundsExceeded,449 /// Tried to enable permissions which are only permitted to be disabled450 OwnerPermissionsCantBeReverted,451 /// Schema data size limit bound exceeded452 SchemaDataLimitExceeded,453 /// Maximum refungibility exceeded454 WrongRefungiblePieces,455 /// createRefungible should be called with one owner456 BadCreateRefungibleCall,457 }458}459460pub trait Config: system::Config + Sized + pallet_transaction_payment::Config + pallet_contracts::Config {461 type Event: From<Event<Self>> + Into<<Self as system::Config>::Event>;462463 /// Weight information for extrinsics in this pallet.464 type WeightInfo: WeightInfo;465466 type EvmAddressMapping: pallet_evm::AddressMapping<Self::AccountId>;467 type EvmBackwardsAddressMapping: EvmBackwardsAddressMapping<Self::AccountId>;468 type EvmWithdrawOrigin: pallet_evm::EnsureAddressOrigin<Self::Origin, Success = Self::AccountId>;469470 type CrossAccountId: CrossAccountId<Self::AccountId>;471 type Currency: Currency<Self::AccountId>;472 type CollectionCreationPrice: Get<<<Self as Config>::Currency as Currency<Self::AccountId>>::Balance>;473 type TreasuryAccountId: Get<Self::AccountId>;474}475476#[cfg(feature = "runtime-benchmarks")]477mod benchmarking;478479// #endregion480481// # Used definitions482//483// ## User control levels484//485// chain-controlled - key is uncontrolled by user486// i.e autoincrementing index487// can use non-cryptographic hash488// real - key is controlled by user489// but it is hard to generate enough colliding values, i.e owner of signed txs490// can use non-cryptographic hash491// controlled - key is completly controlled by users492// i.e maps with mutable keys493// should use cryptographic hash494//495// ## User control level downgrade reasons496//497// ?1 - chain-controlled -> controlled498// collections/tokens can be destroyed, resulting in massive holes499// ?2 - chain-controlled -> controlled500// same as ?1, but can be only added, resulting in easier exploitation501// ?3 - real -> controlled502// no confirmation required, so addresses can be easily generated503decl_storage! {504 trait Store for Module<T: Config> as Nft {505506 //#region Private members507 /// Id of next collection508 CreatedCollectionCount: u32;509 /// Used for migrations510 ChainVersion: u64;511 /// Id of last collection token512 /// Collection id (controlled?1)513 ItemListIndex: map hasher(blake2_128_concat) CollectionId => TokenId;514 //#endregion515516 //#region Chain limits struct517 pub ChainLimit get(fn chain_limit) config(): ChainLimits;518 //#endregion519520 //#region Bound counters521 /// Amount of collections destroyed, used for total amount tracking with522 /// CreatedCollectionCount523 DestroyedCollectionCount: u32;524 /// Total amount of account owned tokens (NFTs + RFTs + unique fungibles)525 /// Account id (real)526 pub AccountItemCount get(fn account_item_count): map hasher(twox_64_concat) T::AccountId => u32;527 //#endregion528529 //#region Basic collections530 /// Collection info531 /// Collection id (controlled?1)532 pub CollectionById get(fn collection_id) config(): map hasher(blake2_128_concat) CollectionId => Option<Collection<T>> = None;533 /// List of collection admins534 /// Collection id (controlled?2)535 pub AdminList get(fn admin_list_collection): map hasher(blake2_128_concat) CollectionId => Vec<T::CrossAccountId>;536 /// Whitelisted collection users537 /// Collection id (controlled?2), user id (controlled?3)538 pub WhiteList get(fn white_list): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) T::AccountId => bool;539 //#endregion540541 /// How many of collection items user have542 /// Collection id (controlled?2), account id (real)543 pub Balance get(fn balance_count): double_map hasher(blake2_128_concat) CollectionId, hasher(twox_64_concat) T::AccountId => u128;544545 /// Amount of items which spender can transfer out of owners account (via transferFrom)546 /// Collection id (controlled?2), (token id (controlled ?2) + owner account id (real) + spender account id (controlled?3))547 /// TODO: Off chain worker should remove from this map when token gets removed548 pub Allowances get(fn approved): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) (TokenId, T::AccountId, T::AccountId) => u128;549550 //#region Item collections551 /// Collection id (controlled?2), token id (controlled?1)552 pub NftItemList get(fn nft_item_id) config(): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => Option<NftItemType<T::CrossAccountId>>;553 /// Collection id (controlled?2), owner (controlled?2)554 pub FungibleItemList get(fn fungible_item_id) config(): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) T::AccountId => FungibleItemType;555 /// Collection id (controlled?2), token id (controlled?1)556 pub ReFungibleItemList get(fn refungible_item_id) config(): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => Option<ReFungibleItemType<T::CrossAccountId>>;557 //#endregion558559 //#region Index list560 /// Collection id (controlled?2), tokens owner (controlled?2)561 pub AddressTokens get(fn address_tokens): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) T::AccountId => Vec<TokenId>;562 //#endregion563564 //#region Tokens transfer rate limit baskets565 /// (Collection id (controlled?2), who created (real))566 /// TODO: Off chain worker should remove from this map when collection gets removed567 pub CreateItemBasket get(fn create_item_basket): map hasher(blake2_128_concat) (CollectionId, T::AccountId) => T::BlockNumber;568 /// Collection id (controlled?2), token id (controlled?2)569 pub NftTransferBasket get(fn nft_transfer_basket): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => T::BlockNumber;570 /// Collection id (controlled?2), owning user (real)571 pub FungibleTransferBasket get(fn fungible_transfer_basket): double_map hasher(blake2_128_concat) CollectionId, hasher(twox_64_concat) T::AccountId => T::BlockNumber;572 /// Collection id (controlled?2), token id (controlled?2)573 pub ReFungibleTransferBasket get(fn refungible_transfer_basket): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => T::BlockNumber;574 //#endregion575576 /// Variable metadata sponsoring577 /// Collection id (controlled?2), token id (controlled?2)578 pub VariableMetaDataBasket get(fn variable_meta_data_basket): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => Option<T::BlockNumber> = None;579 580 //#region Contract Sponsorship and Ownership581 /// Contract address (real)582 pub ContractOwner get(fn contract_owner): map hasher(twox_64_concat) T::AccountId => Option<T::AccountId>;583 /// Contract address (real)584 pub ContractSelfSponsoring get(fn contract_self_sponsoring): map hasher(twox_64_concat) T::AccountId => bool;585 /// (Contract address(real), caller (real))586 pub ContractSponsorBasket get(fn contract_sponsor_basket): map hasher(twox_64_concat) (T::AccountId, T::AccountId) => T::BlockNumber;587 /// Contract address (real)588 pub ContractSponsoringRateLimit get(fn contract_sponsoring_rate_limit): map hasher(twox_64_concat) T::AccountId => T::BlockNumber;589 /// Contract address (real)590 pub ContractWhiteListEnabled get(fn contract_white_list_enabled): map hasher(twox_64_concat) T::AccountId => bool; 591 /// Contract address (real) => Whitelisted user (controlled?3)592 pub ContractWhiteList get(fn contract_white_list): double_map hasher(twox_64_concat) T::AccountId, hasher(blake2_128_concat) T::AccountId => bool; 593 //#endregion594 }595 add_extra_genesis {596 build(|config: &GenesisConfig<T>| {597 // Modification of storage598 for (_num, _c) in &config.collection_id {599 <Module<T>>::init_collection(_c);600 }601602 for (_num, _c, _i) in &config.nft_item_id {603 <Module<T>>::init_nft_token(*_c, _i);604 }605606 for (collection_id, account_id, fungible_item) in &config.fungible_item_id {607 <Module<T>>::init_fungible_token(*collection_id, account_id, fungible_item);608 }609610 for (_num, _c, _i) in &config.refungible_item_id {611 <Module<T>>::init_refungible_token(*_c, _i);612 }613 })614 }615}616617decl_event!(618 pub enum Event<T>619 where620 CrossAccountId = <T as Config>::CrossAccountId,621 {622 /// New collection was created623 /// 624 /// # Arguments625 /// 626 /// * collection_id: Globally unique identifier of newly created collection.627 /// 628 /// * mode: [CollectionMode] converted into u8.629 /// 630 /// * account_id: Collection owner.631 CollectionCreated(CollectionId, u8, CrossAccountId),632633 /// New item was created.634 /// 635 /// # Arguments636 /// 637 /// * collection_id: Id of the collection where item was created.638 /// 639 /// * item_id: Id of an item. Unique within the collection.640 ///641 /// * recipient: Owner of newly created item 642 ItemCreated(CollectionId, TokenId, CrossAccountId),643644 /// Collection item was burned.645 /// 646 /// # Arguments647 /// 648 /// collection_id.649 /// 650 /// item_id: Identifier of burned NFT.651 ItemDestroyed(CollectionId, TokenId),652653 /// Item was transferred654 ///655 /// * collection_id: Id of collection to which item is belong656 ///657 /// * item_id: Id of an item658 ///659 /// * sender: Original owner of item660 ///661 /// * recipient: New owner of item662 ///663 /// * amount: Always 1 for NFT664 Transfer(CollectionId, TokenId, CrossAccountId, CrossAccountId, u128),665666 /// * collection_id667 ///668 /// * item_id669 ///670 /// * sender671 ///672 /// * spender673 ///674 /// * amount675 Approved(CollectionId, TokenId, CrossAccountId, CrossAccountId, u128),676 }677);678679decl_module! {680 pub struct Module<T: Config> for enum Call 681 where 682 origin: T::Origin683 {684 fn deposit_event() = default;685 type Error = Error<T>;686687 fn on_initialize(now: T::BlockNumber) -> Weight {688 0689 }690691 /// This method creates a Collection of NFTs. Each Token may have multiple properties encoded as an array of bytes of certain length. The initial owner and admin of the collection are set to the address that signed the transaction. Both addresses can be changed later.692 /// 693 /// # Permissions694 /// 695 /// * Anyone.696 /// 697 /// # Arguments698 /// 699 /// * collection_name: UTF-16 string with collection name (limit 64 characters), will be stored as zero-terminated.700 /// 701 /// * collection_description: UTF-16 string with collection description (limit 256 characters), will be stored as zero-terminated.702 /// 703 /// * token_prefix: UTF-8 string with token prefix.704 /// 705 /// * mode: [CollectionMode] collection type and type dependent data.706 // returns collection ID707 #[weight = <T as Config>::WeightInfo::create_collection()]708 #[transactional]709 pub fn create_collection(origin,710 collection_name: Vec<u16>,711 collection_description: Vec<u16>,712 token_prefix: Vec<u8>,713 mode: CollectionMode) -> DispatchResult {714715 // Anyone can create a collection716 let who = ensure_signed(origin)?;717718 // Take a (non-refundable) deposit of collection creation719 let mut imbalance = <<<T as Config>::Currency as Currency<T::AccountId>>::PositiveImbalance>::zero();720 imbalance.subsume(<<T as Config>::Currency as Currency<T::AccountId>>::deposit_creating(721 &T::TreasuryAccountId::get(),722 T::CollectionCreationPrice::get(),723 ));724 <T as Config>::Currency::settle(725 &who,726 imbalance,727 WithdrawReasons::TRANSFER,728 ExistenceRequirement::KeepAlive,729 ).map_err(|_| Error::<T>::NoPermission)?;730731 let decimal_points = match mode {732 CollectionMode::Fungible(points) => points,733 _ => 0734 };735736 let chain_limit = ChainLimit::get();737738 let created_count = CreatedCollectionCount::get();739 let destroyed_count = DestroyedCollectionCount::get();740741 // bound Total number of collections742 ensure!(created_count - destroyed_count < chain_limit.collection_numbers_limit, Error::<T>::TotalCollectionsLimitExceeded);743744 // check params745 ensure!(decimal_points <= MAX_DECIMAL_POINTS, Error::<T>::CollectionDecimalPointLimitExceeded);746 ensure!(collection_name.len() <= 64, Error::<T>::CollectionNameLimitExceeded);747 ensure!(collection_description.len() <= 256, Error::<T>::CollectionDescriptionLimitExceeded);748 ensure!(token_prefix.len() <= 16, Error::<T>::CollectionTokenPrefixLimitExceeded);749750 // Generate next collection ID751 let next_id = created_count752 .checked_add(1)753 .ok_or(Error::<T>::NumOverflow)?;754755 CreatedCollectionCount::put(next_id);756757 let limits = CollectionLimits {758 sponsored_data_size: chain_limit.custom_data_limit,759 ..Default::default()760 };761762 // Create new collection763 let new_collection = Collection {764 owner: who.clone(),765 name: collection_name,766 mode: mode.clone(),767 mint_mode: false,768 access: AccessMode::Normal,769 description: collection_description,770 decimal_points: decimal_points,771 token_prefix: token_prefix,772 offchain_schema: Vec::new(),773 schema_version: SchemaVersion::ImageURL,774 sponsorship: SponsorshipState::Disabled,775 variable_on_chain_schema: Vec::new(),776 const_on_chain_schema: Vec::new(),777 limits,778 };779780 // Add new collection to map781 <CollectionById<T>>::insert(next_id, new_collection);782783 // call event784 Self::deposit_event(RawEvent::CollectionCreated(next_id, mode.into(), who.clone()));785786 Ok(())787 }788789 /// **DANGEROUS**: Destroys collection and all NFTs within this collection. Users irrecoverably lose their assets and may lose real money.790 /// 791 /// # Permissions792 /// 793 /// * Collection Owner.794 /// 795 /// # Arguments796 /// 797 /// * collection_id: collection to destroy.798 #[weight = <T as Config>::WeightInfo::destroy_collection()]799 #[transactional]800 pub fn destroy_collection(origin, collection_id: CollectionId) -> DispatchResult {801802 let sender = ensure_signed(origin)?;803 let collection = Self::get_collection(collection_id)?;804 Self::check_owner_permissions(&collection, sender)?;805 if !collection.limits.owner_can_destroy {806 fail!(Error::<T>::NoPermission);807 }808809 <AddressTokens<T>>::remove_prefix(collection_id);810 <Allowances<T>>::remove_prefix(collection_id);811 <Balance<T>>::remove_prefix(collection_id);812 <ItemListIndex>::remove(collection_id);813 <AdminList<T>>::remove(collection_id);814 <CollectionById<T>>::remove(collection_id);815 <WhiteList<T>>::remove_prefix(collection_id);816817 <NftItemList<T>>::remove_prefix(collection_id);818 <FungibleItemList<T>>::remove_prefix(collection_id);819 <ReFungibleItemList<T>>::remove_prefix(collection_id);820821 <NftTransferBasket<T>>::remove_prefix(collection_id);822 <FungibleTransferBasket<T>>::remove_prefix(collection_id);823 <ReFungibleTransferBasket<T>>::remove_prefix(collection_id);824825 <VariableMetaDataBasket<T>>::remove_prefix(collection_id);826827 DestroyedCollectionCount::put(DestroyedCollectionCount::get()828 .checked_add(1)829 .ok_or(Error::<T>::NumOverflow)?);830831 Ok(())832 }833834 /// Add an address to white list.835 /// 836 /// # Permissions837 /// 838 /// * Collection Owner839 /// * Collection Admin840 /// 841 /// # Arguments842 /// 843 /// * collection_id.844 /// 845 /// * address.846 #[weight = <T as Config>::WeightInfo::add_to_white_list()]847 #[transactional]848 pub fn add_to_white_list(origin, collection_id: CollectionId, address: T::AccountId) -> DispatchResult{849850 let sender = ensure_signed(origin)?;851 let collection = Self::get_collection(collection_id)?;852 Self::check_owner_or_admin_permissions(&collection, sender)?;853854 <WhiteList<T>>::insert(collection_id, address, true);855 856 Ok(())857 }858859 /// Remove an address from white list.860 /// 861 /// # Permissions862 /// 863 /// * Collection Owner864 /// * Collection Admin865 /// 866 /// # Arguments867 /// 868 /// * collection_id.869 /// 870 /// * address.871 #[weight = <T as Config>::WeightInfo::remove_from_white_list()]872 #[transactional]873 pub fn remove_from_white_list(origin, collection_id: CollectionId, address: T::AccountId) -> DispatchResult{874875 let sender = ensure_signed(origin)?;876 let collection = Self::get_collection(collection_id)?;877 Self::check_owner_or_admin_permissions(&collection, sender)?;878879 <WhiteList<T>>::remove(collection_id, address);880881 Ok(())882 }883884 /// Toggle between normal and white list access for the methods with access for `Anyone`.885 /// 886 /// # Permissions887 /// 888 /// * Collection Owner.889 /// 890 /// # Arguments891 /// 892 /// * collection_id.893 /// 894 /// * mode: [AccessMode]895 #[weight = <T as Config>::WeightInfo::set_public_access_mode()]896 #[transactional]897 pub fn set_public_access_mode(origin, collection_id: CollectionId, mode: AccessMode) -> DispatchResult898 {899 let sender = ensure_signed(origin)?;900901 let mut target_collection = Self::get_collection(collection_id)?;902 Self::check_owner_permissions(&target_collection, sender)?;903 target_collection.access = mode;904 Self::save_collection(target_collection);905906 Ok(())907 }908909 /// Allows Anyone to create tokens if:910 /// * White List is enabled, and911 /// * Address is added to white list, and912 /// * This method was called with True parameter913 /// 914 /// # Permissions915 /// * Collection Owner916 ///917 /// # Arguments918 /// 919 /// * collection_id.920 /// 921 /// * mint_permission: Boolean parameter. If True, allows minting to Anyone with conditions above.922 #[weight = <T as Config>::WeightInfo::set_mint_permission()]923 #[transactional]924 pub fn set_mint_permission(origin, collection_id: CollectionId, mint_permission: bool) -> DispatchResult925 {926 let sender = ensure_signed(origin)?;927928 let mut target_collection = Self::get_collection(collection_id)?;929 Self::check_owner_permissions(&target_collection, sender)?;930 target_collection.mint_mode = mint_permission;931 Self::save_collection(target_collection);932933 Ok(())934 }935936 /// Change the owner of the collection.937 /// 938 /// # Permissions939 /// 940 /// * Collection Owner.941 /// 942 /// # Arguments943 /// 944 /// * collection_id.945 /// 946 /// * new_owner.947 #[weight = <T as Config>::WeightInfo::change_collection_owner()]948 #[transactional]949 pub fn change_collection_owner(origin, collection_id: CollectionId, new_owner: T::AccountId) -> DispatchResult {950951 let sender = ensure_signed(origin)?;952 let mut target_collection = Self::get_collection(collection_id)?;953 Self::check_owner_permissions(&target_collection, sender)?;954 target_collection.owner = new_owner;955 Self::save_collection(target_collection);956957 Ok(())958 }959960 /// Adds an admin of the Collection.961 /// NFT Collection can be controlled by multiple admin addresses (some which can also be servers, for example). Admins can issue and burn NFTs, as well as add and remove other admins, but cannot change NFT or Collection ownership. 962 /// 963 /// # Permissions964 /// 965 /// * Collection Owner.966 /// * Collection Admin.967 /// 968 /// # Arguments969 /// 970 /// * collection_id: ID of the Collection to add admin for.971 /// 972 /// * new_admin_id: Address of new admin to add.973 #[weight = <T as Config>::WeightInfo::add_collection_admin()]974 #[transactional]975 pub fn add_collection_admin(origin, collection_id: CollectionId, new_admin_id: T::AccountId) -> DispatchResult {976977 let sender = ensure_signed(origin)?;978 let collection = Self::get_collection(collection_id)?;979 Self::check_owner_or_admin_permissions(&collection, sender)?;980 let mut admin_arr = <AdminList<T>>::get(collection_id);981982 match admin_arr.binary_search(&new_admin_id) {983 Ok(_) => {},984 Err(idx) => {985 let limits = ChainLimit::get();986 ensure!(admin_arr.len() < limits.collections_admins_limit as usize, Error::<T>::CollectionAdminsLimitExceeded);987 admin_arr.insert(idx, new_admin_id);988 <AdminList<T>>::insert(collection_id, admin_arr);989 }990 }991 Ok(())992 }993994 /// 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.995 ///996 /// # Permissions997 /// 998 /// * Collection Owner.999 /// * Collection Admin.1000 /// 1001 /// # Arguments1002 /// 1003 /// * collection_id: ID of the Collection to remove admin for.1004 /// 1005 /// * account_id: Address of admin to remove.1006 #[weight = <T as Config>::WeightInfo::remove_collection_admin()]1007 #[transactional]1008 pub fn remove_collection_admin(origin, collection_id: CollectionId, account_id: T::AccountId) -> DispatchResult {10091010 let sender = ensure_signed(origin)?;1011 let collection = Self::get_collection(collection_id)?;1012 Self::check_owner_or_admin_permissions(&collection, sender)?;1013 let mut admin_arr = <AdminList<T>>::get(collection_id);10141015 match admin_arr.binary_search(&account_id) {1016 Ok(idx) => {1017 admin_arr.remove(idx);1018 <AdminList<T>>::insert(collection_id, admin_arr);1019 },1020 Err(_) => {}1021 }1022 Ok(())1023 }10241025 /// # Permissions1026 /// 1027 /// * Collection Owner1028 /// 1029 /// # Arguments1030 /// 1031 /// * collection_id.1032 /// 1033 /// * new_sponsor.1034 #[weight = <T as Config>::WeightInfo::set_collection_sponsor()]1035 #[transactional]1036 pub fn set_collection_sponsor(origin, collection_id: CollectionId, new_sponsor: T::AccountId) -> DispatchResult {10371038 let sender = ensure_signed(origin)?;1039 let mut target_collection = Self::get_collection(collection_id)?;1040 Self::check_owner_permissions(&target_collection, sender)?;10411042 target_collection.sponsorship = SponsorshipState::Unconfirmed(new_sponsor);1043 Self::save_collection(target_collection);10441045 Ok(())1046 }10471048 /// # Permissions1049 /// 1050 /// * Sponsor.1051 /// 1052 /// # Arguments1053 /// 1054 /// * collection_id.1055 #[weight = <T as Config>::WeightInfo::confirm_sponsorship()]1056 #[transactional]1057 pub fn confirm_sponsorship(origin, collection_id: CollectionId) -> DispatchResult {10581059 let sender = ensure_signed(origin)?;10601061 let mut target_collection = Self::get_collection(collection_id)?;1062 ensure!(1063 target_collection.sponsorship.pending_sponsor() == Some(&sender),1064 Error::<T>::ConfirmUnsetSponsorFail1065 );10661067 target_collection.sponsorship = SponsorshipState::Confirmed(sender);1068 Self::save_collection(target_collection);10691070 Ok(())1071 }10721073 /// Switch back to pay-per-own-transaction model.1074 ///1075 /// # Permissions1076 ///1077 /// * Collection owner.1078 /// 1079 /// # Arguments1080 /// 1081 /// * collection_id.1082 #[weight = <T as Config>::WeightInfo::remove_collection_sponsor()]1083 #[transactional]1084 pub fn remove_collection_sponsor(origin, collection_id: CollectionId) -> DispatchResult {10851086 let sender = ensure_signed(origin)?;10871088 let mut target_collection = Self::get_collection(collection_id)?;1089 Self::check_owner_permissions(&target_collection, sender)?;10901091 target_collection.sponsorship = SponsorshipState::Disabled;1092 Self::save_collection(target_collection);10931094 Ok(())1095 }10961097 /// This method creates a concrete instance of NFT Collection created with CreateCollection method.1098 /// 1099 /// # Permissions1100 /// 1101 /// * Collection Owner.1102 /// * Collection Admin.1103 /// * Anyone if1104 /// * White List is enabled, and1105 /// * Address is added to white list, and1106 /// * MintPermission is enabled (see SetMintPermission method)1107 /// 1108 /// # Arguments1109 /// 1110 /// * collection_id: ID of the collection.1111 /// 1112 /// * owner: Address, initial owner of the NFT.1113 ///1114 /// * data: Token data to store on chain.1115 // #[weight =1116 // (130_000_000 as Weight)1117 // .saturating_add((2135 as Weight).saturating_mul((properties.len() as u64) as Weight))1118 // .saturating_add(RocksDbWeight::get().reads(10 as Weight))1119 // .saturating_add(RocksDbWeight::get().writes(8 as Weight))]11201121 #[weight = <T as Config>::WeightInfo::create_item(data.len())]1122 #[transactional]1123 pub fn create_item(origin, collection_id: CollectionId, owner: T::AccountId, data: CreateItemData) -> DispatchResult {11241125 let sender = ensure_signed(origin)?;11261127 let target_collection = Self::get_collection(collection_id)?;11281129 Self::can_create_items_in_collection(&target_collection, &sender, &owner, 1)?;1130 Self::validate_create_item_args(&target_collection, &data)?;1131 Self::create_item_no_validation(&target_collection, owner, data)?;11321133 Ok(())1134 }11351136 /// This method creates multiple items in a collection created with CreateCollection method.1137 /// 1138 /// # Permissions1139 /// 1140 /// * Collection Owner.1141 /// * Collection Admin.1142 /// * Anyone if1143 /// * White List is enabled, and1144 /// * Address is added to white list, and1145 /// * MintPermission is enabled (see SetMintPermission method)1146 /// 1147 /// # Arguments1148 /// 1149 /// * collection_id: ID of the collection.1150 /// 1151 /// * itemsData: Array items properties. Each property is an array of bytes itself, see [create_item].1152 /// 1153 /// * owner: Address, initial owner of the NFT.1154 #[weight = <T as Config>::WeightInfo::create_item(items_data.into_iter()1155 .map(|data| { data.len() })1156 .sum())]1157 #[transactional]1158 pub fn create_multiple_items(origin, collection_id: CollectionId, owner: T::AccountId, items_data: Vec<CreateItemData>) -> DispatchResult {11591160 ensure!(items_data.len() > 0, Error::<T>::EmptyArgument);1161 let sender = ensure_signed(origin)?;11621163 let target_collection = Self::get_collection(collection_id)?;11641165 Self::can_create_items_in_collection(&target_collection, &sender, &owner, items_data.len() as u32)?;11661167 for data in &items_data {1168 Self::validate_create_item_args(&target_collection, data)?;1169 }1170 for data in &items_data {1171 Self::create_item_no_validation(&target_collection, owner.clone(), data.clone())?;1172 }11731174 Ok(())1175 }11761177 /// Destroys a concrete instance of NFT.1178 /// 1179 /// # Permissions1180 /// 1181 /// * Collection Owner.1182 /// * Collection Admin.1183 /// * Current NFT Owner.1184 /// 1185 /// # Arguments1186 /// 1187 /// * collection_id: ID of the collection.1188 /// 1189 /// * item_id: ID of NFT to burn.1190 #[weight = <T as Config>::WeightInfo::burn_item()]1191 #[transactional]1192 pub fn burn_item(origin, collection_id: CollectionId, item_id: TokenId, value: u128) -> DispatchResult {11931194 let sender = ensure_signed(origin)?;11951196 // Transfer permissions check1197 let target_collection = Self::get_collection(collection_id)?;1198 ensure!(1199 Self::is_item_owner(sender.clone(), &target_collection, item_id) ||1200 (1201 target_collection.limits.owner_can_transfer &&1202 Self::is_owner_or_admin_permissions(&target_collection, sender.clone())1203 ),1204 Error::<T>::NoPermission1205 );12061207 if target_collection.access == AccessMode::WhiteList {1208 Self::check_white_list(&target_collection, &sender)?;1209 }12101211 match target_collection.mode1212 {1213 CollectionMode::NFT => Self::burn_nft_item(&target_collection, item_id)?,1214 CollectionMode::Fungible(_) => Self::burn_fungible_item(&sender, &target_collection, value)?,1215 CollectionMode::ReFungible => Self::burn_refungible_item(&target_collection, item_id, &sender)?,1216 _ => ()1217 };12181219 // call event1220 Self::deposit_event(RawEvent::ItemDestroyed(target_collection.id, item_id));12211222 Ok(())1223 }12241225 /// Change ownership of the token.1226 /// 1227 /// # Permissions1228 /// 1229 /// * Collection Owner1230 /// * Collection Admin1231 /// * Current NFT owner1232 ///1233 /// # Arguments1234 /// 1235 /// * recipient: Address of token recipient.1236 /// 1237 /// * collection_id.1238 /// 1239 /// * item_id: ID of the item1240 /// * Non-Fungible Mode: Required.1241 /// * Fungible Mode: Ignored.1242 /// * Re-Fungible Mode: Required.1243 /// 1244 /// * value: Amount to transfer.1245 /// * Non-Fungible Mode: Ignored1246 /// * Fungible Mode: Must specify transferred amount1247 /// * Re-Fungible Mode: Must specify transferred portion (between 0 and 1)1248 #[weight = <T as Config>::WeightInfo::transfer()]1249 #[transactional]1250 pub fn transfer(origin, recipient: T::AccountId, collection_id: CollectionId, item_id: TokenId, value: u128) -> DispatchResult {1251 let sender = ensure_signed(origin)?;1252 let collection = Self::get_collection(collection_id)?;12531254 Self::transfer_internal(sender, recipient, &collection, item_id, value)1255 }12561257 /// Set, change, or remove approved address to transfer the ownership of the NFT.1258 /// 1259 /// # Permissions1260 /// 1261 /// * Collection Owner1262 /// * Collection Admin1263 /// * Current NFT owner1264 /// 1265 /// # Arguments1266 /// 1267 /// * approved: Address that is approved to transfer this NFT or zero (if needed to remove approval).1268 /// 1269 /// * collection_id.1270 /// 1271 /// * item_id: ID of the item.1272 #[weight = <T as Config>::WeightInfo::approve()]1273 #[transactional]1274 pub fn approve(origin, spender: T::AccountId, collection_id: CollectionId, item_id: TokenId, amount: u128) -> DispatchResult {12751276 let sender = ensure_signed(origin)?;1277 let target_collection = Self::get_collection(collection_id)?;12781279 Self::token_exists(&target_collection, item_id)?;12801281 // Transfer permissions check1282 let bypasses_limits = target_collection.limits.owner_can_transfer &&1283 Self::is_owner_or_admin_permissions(1284 &target_collection,1285 sender.clone(),1286 );12871288 let allowance_limit = if bypasses_limits {1289 None1290 } else if let Some(amount) = Self::owned_amount(1291 sender.clone(),1292 &target_collection,1293 item_id,1294 ) {1295 Some(amount)1296 } else {1297 fail!(Error::<T>::NoPermission);1298 };12991300 if target_collection.access == AccessMode::WhiteList {1301 Self::check_white_list(&target_collection, &sender)?;1302 Self::check_white_list(&target_collection, &spender)?;1303 }13041305 let allowance: u128 = amount1306 .checked_add(<Allowances<T>>::get(collection_id, (item_id, &sender, &spender)))1307 .ok_or(Error::<T>::NumOverflow)?;1308 if let Some(limit) = allowance_limit {1309 ensure!(limit >= allowance, Error::<T>::TokenValueTooLow);1310 }1311 <Allowances<T>>::insert(collection_id, (item_id, sender.clone(), spender.clone()), allowance);13121313 Self::deposit_event(RawEvent::Approved(target_collection.id, item_id, sender, spender, allowance));1314 Ok(())1315 }1316 1317 /// 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.1318 /// 1319 /// # Permissions1320 /// * Collection Owner1321 /// * Collection Admin1322 /// * Current NFT owner1323 /// * Address approved by current NFT owner1324 /// 1325 /// # Arguments1326 /// 1327 /// * from: Address that owns token.1328 /// 1329 /// * recipient: Address of token recipient.1330 /// 1331 /// * collection_id.1332 /// 1333 /// * item_id: ID of the item.1334 /// 1335 /// * value: Amount to transfer.1336 #[weight = <T as Config>::WeightInfo::transfer_from()]1337 #[transactional]1338 pub fn transfer_from(origin, from: T::AccountId, recipient: T::AccountId, collection_id: CollectionId, item_id: TokenId, value: u128 ) -> DispatchResult {13391340 let sender = ensure_signed(origin)?;1341 let target_collection = Self::get_collection(collection_id)?;13421343 // Check approval1344 let approval: u128 = <Allowances<T>>::get(collection_id, (item_id, &from, &sender));13451346 // Limits check1347 Self::is_correct_transfer(&target_collection, &recipient)?;13481349 // Transfer permissions check 1350 ensure!(1351 approval >= value || 1352 (1353 target_collection.limits.owner_can_transfer &&1354 Self::is_owner_or_admin_permissions(&target_collection, sender.clone())1355 ),1356 Error::<T>::NoPermission1357 );13581359 if target_collection.access == AccessMode::WhiteList {1360 Self::check_white_list(&target_collection, &sender)?;1361 Self::check_white_list(&target_collection, &recipient)?;1362 }13631364 // Reduce approval by transferred amount or remove if remaining approval drops to 01365 if approval.saturating_sub(value) > 0 {1366 <Allowances<T>>::insert(collection_id, (item_id, &from, &sender), approval - value);1367 }1368 else {1369 <Allowances<T>>::remove(collection_id, (item_id, &from, &sender));1370 }13711372 match target_collection.mode1373 {1374 CollectionMode::NFT => Self::transfer_nft(&target_collection, item_id, from.clone(), recipient.clone())?,1375 CollectionMode::Fungible(_) => Self::transfer_fungible(&target_collection, value, &from, &recipient)?,1376 CollectionMode::ReFungible => Self::transfer_refungible(&target_collection, item_id, value, from.clone(), recipient.clone())?,1377 _ => ()1378 };13791380 Self::deposit_event(RawEvent::Transfer(target_collection.id, item_id, from, recipient, value));1381 Ok(())1382 }13831384 // #[weight = 0]1385 // pub fn safe_transfer_from(origin, collection_id: CollectionId, item_id: TokenId, new_owner: T::AccountId) -> DispatchResult {13861387 // // let no_perm_mes = "You do not have permissions to modify this collection";1388 // // ensure!(<ApprovedList<T>>::contains_key((collection_id, item_id)), no_perm_mes);1389 // // let list_itm = <ApprovedList<T>>::get((collection_id, item_id));1390 // // ensure!(list_itm.contains(&new_owner.clone()), no_perm_mes);13911392 // // // on_nft_received call13931394 // // Self::transfer(origin, collection_id, item_id, new_owner)?;13951396 // Ok(())1397 // }13981399 /// Set off-chain data schema.1400 /// 1401 /// # Permissions1402 /// 1403 /// * Collection Owner1404 /// * Collection Admin1405 /// 1406 /// # Arguments1407 /// 1408 /// * collection_id.1409 /// 1410 /// * schema: String representing the offchain data schema.1411 #[weight = <T as Config>::WeightInfo::set_variable_meta_data()]1412 #[transactional]1413 pub fn set_variable_meta_data (1414 origin,1415 collection_id: CollectionId,1416 item_id: TokenId,1417 data: Vec<u8>1418 ) -> DispatchResult {1419 let sender = ensure_signed(origin)?;1420 1421 let target_collection = Self::get_collection(collection_id)?;1422 Self::token_exists(&target_collection, item_id)?;14231424 ensure!(ChainLimit::get().custom_data_limit >= data.len() as u32, Error::<T>::TokenVariableDataLimitExceeded);14251426 // Modify permissions check1427 ensure!(Self::is_item_owner(sender.clone(), &target_collection, item_id) ||1428 Self::is_owner_or_admin_permissions(&target_collection, sender.clone()),1429 Error::<T>::NoPermission);14301431 match target_collection.mode1432 {1433 CollectionMode::NFT => Self::set_nft_variable_data(&target_collection, item_id, data)?,1434 CollectionMode::ReFungible => Self::set_re_fungible_variable_data(&target_collection, item_id, data)?,1435 CollectionMode::Fungible(_) => fail!(Error::<T>::CantStoreMetadataInFungibleTokens),1436 _ => fail!(Error::<T>::UnexpectedCollectionType)1437 };14381439 Ok(())1440 }1441 1442 /// Set schema standard1443 /// ImageURL1444 /// Unique1445 /// 1446 /// # Permissions1447 /// 1448 /// * Collection Owner1449 /// * Collection Admin1450 /// 1451 /// # Arguments1452 /// 1453 /// * collection_id.1454 /// 1455 /// * schema: SchemaVersion: enum1456 #[weight = <T as Config>::WeightInfo::set_schema_version()]1457 #[transactional]1458 pub fn set_schema_version(1459 origin,1460 collection_id: CollectionId,1461 version: SchemaVersion1462 ) -> DispatchResult {1463 let sender = ensure_signed(origin)?;1464 let mut target_collection = Self::get_collection(collection_id)?;1465 Self::check_owner_or_admin_permissions(&target_collection, sender.clone())?;1466 target_collection.schema_version = version;1467 Self::save_collection(target_collection);14681469 Ok(())1470 }14711472 /// Set off-chain data schema.1473 /// 1474 /// # Permissions1475 /// 1476 /// * Collection Owner1477 /// * Collection Admin1478 /// 1479 /// # Arguments1480 /// 1481 /// * collection_id.1482 /// 1483 /// * schema: String representing the offchain data schema.1484 #[weight = <T as Config>::WeightInfo::set_offchain_schema()]1485 #[transactional]1486 pub fn set_offchain_schema(1487 origin,1488 collection_id: CollectionId,1489 schema: Vec<u8>1490 ) -> DispatchResult {1491 let sender = ensure_signed(origin)?;1492 let mut target_collection = Self::get_collection(collection_id)?;1493 Self::check_owner_or_admin_permissions(&target_collection, sender.clone())?;14941495 // check schema limit1496 ensure!(schema.len() as u32 <= ChainLimit::get().offchain_schema_limit, "");14971498 target_collection.offchain_schema = schema;1499 Self::save_collection(target_collection);15001501 Ok(())1502 }15031504 /// Set const on-chain data schema.1505 /// 1506 /// # Permissions1507 /// 1508 /// * Collection Owner1509 /// * Collection Admin1510 /// 1511 /// # Arguments1512 /// 1513 /// * collection_id.1514 /// 1515 /// * schema: String representing the const on-chain data schema.1516 #[weight = <T as Config>::WeightInfo::set_const_on_chain_schema()]1517 #[transactional]1518 pub fn set_const_on_chain_schema (1519 origin,1520 collection_id: CollectionId,1521 schema: Vec<u8>1522 ) -> DispatchResult {1523 let sender = ensure_signed(origin)?;1524 let mut target_collection = Self::get_collection(collection_id)?;1525 Self::check_owner_or_admin_permissions(&target_collection, sender.clone())?;15261527 // check schema limit1528 ensure!(schema.len() as u32 <= ChainLimit::get().const_on_chain_schema_limit, "");15291530 target_collection.const_on_chain_schema = schema;1531 Self::save_collection(target_collection);15321533 Ok(())1534 }15351536 /// Set variable on-chain data schema.1537 /// 1538 /// # Permissions1539 /// 1540 /// * Collection Owner1541 /// * Collection Admin1542 /// 1543 /// # Arguments1544 /// 1545 /// * collection_id.1546 /// 1547 /// * schema: String representing the variable on-chain data schema.1548 #[weight = <T as Config>::WeightInfo::set_const_on_chain_schema()]1549 #[transactional]1550 pub fn set_variable_on_chain_schema (1551 origin,1552 collection_id: CollectionId,1553 schema: Vec<u8>1554 ) -> DispatchResult {1555 let sender = ensure_signed(origin)?;1556 let mut target_collection = Self::get_collection(collection_id)?;1557 Self::check_owner_or_admin_permissions(&target_collection, sender.clone())?;15581559 // check schema limit1560 ensure!(schema.len() as u32 <= ChainLimit::get().variable_on_chain_schema_limit, "");15611562 target_collection.variable_on_chain_schema = schema;1563 Self::save_collection(target_collection);15641565 Ok(())1566 }15671568 // Sudo permissions function1569 #[weight = <T as Config>::WeightInfo::set_chain_limits()]1570 #[transactional]1571 pub fn set_chain_limits(1572 origin,1573 limits: ChainLimits1574 ) -> DispatchResult {15751576 #[cfg(not(feature = "runtime-benchmarks"))]1577 ensure_root(origin)?;15781579 <ChainLimit>::put(limits);1580 Ok(())1581 }15821583 /// Enable smart contract self-sponsoring.1584 /// 1585 /// # Permissions1586 /// 1587 /// * Contract Owner1588 /// 1589 /// # Arguments1590 /// 1591 /// * contract address1592 /// * enable flag1593 /// 1594 #[weight = <T as Config>::WeightInfo::enable_contract_sponsoring()]1595 #[transactional]1596 pub fn enable_contract_sponsoring(1597 origin,1598 contract_address: T::AccountId,1599 enable: bool1600 ) -> DispatchResult {16011602 let sender = ensure_signed(origin)?;16031604 #[cfg(feature = "runtime-benchmarks")]1605 <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());16061607 Self::ensure_contract_owned(sender, &contract_address)?;16081609 <ContractSelfSponsoring<T>>::insert(contract_address, enable);1610 Ok(())1611 }16121613 /// Set the rate limit for contract sponsoring to specified number of blocks.1614 /// 1615 /// If not set (has the default value of 0 blocks), the sponsoring will be disabled. 1616 /// If set to the number B (for blocks), the transactions will be sponsored with a rate 1617 /// limit of B, i.e. fees for every transaction sent to this smart contract will be paid 1618 /// from contract endowment if there are at least B blocks between such transactions. 1619 /// Nonetheless, if transactions are sent more frequently, the fees are paid by the sender.1620 /// 1621 /// # Permissions1622 /// 1623 /// * Contract Owner1624 /// 1625 /// # Arguments1626 /// 1627 /// -`contract_address`: Address of the contract to sponsor1628 /// -`rate_limit`: Number of blocks to wait until the next sponsored transaction is allowed1629 /// 1630 #[weight = <T as Config>::WeightInfo::set_contract_sponsoring_rate_limit()]1631 #[transactional]1632 pub fn set_contract_sponsoring_rate_limit(1633 origin,1634 contract_address: T::AccountId,1635 rate_limit: T::BlockNumber1636 ) -> DispatchResult {1637 let sender = ensure_signed(origin)?;16381639 #[cfg(feature = "runtime-benchmarks")]1640 <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());16411642 Self::ensure_contract_owned(sender, &contract_address)?;1643 <ContractSponsoringRateLimit<T>>::insert(contract_address, rate_limit);1644 Ok(())1645 }16461647 /// Enable the white list for a contract. Only addresses added to the white list with addToContractWhiteList will be able to call this smart contract.1648 /// 1649 /// # Permissions1650 /// 1651 /// * Address that deployed smart contract.1652 /// 1653 /// # Arguments1654 /// 1655 /// -`contract_address`: Address of the contract.1656 /// 1657 /// - `enable`: . 1658 #[weight = <T as Config>::WeightInfo::toggle_contract_white_list()]1659 #[transactional]1660 pub fn toggle_contract_white_list(1661 origin,1662 contract_address: T::AccountId,1663 enable: bool1664 ) -> DispatchResult {1665 let sender = ensure_signed(origin)?;16661667 #[cfg(feature = "runtime-benchmarks")]1668 <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());16691670 Self::ensure_contract_owned(sender, &contract_address)?;1671 if enable {1672 <ContractWhiteListEnabled<T>>::insert(contract_address, true);1673 } else {1674 <ContractWhiteListEnabled<T>>::remove(contract_address);1675 }1676 Ok(())1677 }1678 1679 /// Add an address to smart contract white list.1680 /// 1681 /// # Permissions1682 /// 1683 /// * Address that deployed smart contract.1684 /// 1685 /// # Arguments1686 /// 1687 /// -`contract_address`: Address of the contract.1688 ///1689 /// -`account_address`: Address to add.1690 #[weight = <T as Config>::WeightInfo::add_to_contract_white_list()]1691 #[transactional]1692 pub fn add_to_contract_white_list(1693 origin,1694 contract_address: T::AccountId,1695 account_address: T::AccountId1696 ) -> DispatchResult {1697 let sender = ensure_signed(origin)?;16981699 #[cfg(feature = "runtime-benchmarks")]1700 <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());1701 1702 Self::ensure_contract_owned(sender, &contract_address)?; 1703 <ContractWhiteList<T>>::insert(contract_address, account_address, true);1704 Ok(())1705 }17061707 /// Remove an address from smart contract white list.1708 /// 1709 /// # Permissions1710 /// 1711 /// * Address that deployed smart contract.1712 /// 1713 /// # Arguments1714 /// 1715 /// -`contract_address`: Address of the contract.1716 ///1717 /// -`account_address`: Address to remove.1718 #[weight = <T as Config>::WeightInfo::remove_from_contract_white_list()]1719 #[transactional]1720 pub fn remove_from_contract_white_list(1721 origin,1722 contract_address: T::AccountId,1723 account_address: T::AccountId1724 ) -> DispatchResult {1725 let sender = ensure_signed(origin)?;17261727 #[cfg(feature = "runtime-benchmarks")]1728 <ContractOwner<T>>::insert(contract_address.clone(), sender.clone());17291730 Self::ensure_contract_owned(sender, &contract_address)?;1731 <ContractWhiteList<T>>::remove(contract_address, account_address);1732 Ok(())1733 }17341735 #[weight = <T as Config>::WeightInfo::set_collection_limits()]1736 #[transactional]1737 pub fn set_collection_limits(1738 origin,1739 collection_id: u32,1740 new_limits: CollectionLimits<T::BlockNumber>,1741 ) -> DispatchResult {1742 let sender = ensure_signed(origin)?;1743 let mut target_collection = Self::get_collection(collection_id)?;1744 Self::check_owner_permissions(&target_collection, sender.clone())?;1745 let old_limits = &target_collection.limits;1746 let chain_limits = ChainLimit::get();17471748 // collection bounds1749 ensure!(new_limits.sponsor_transfer_timeout <= MAX_SPONSOR_TIMEOUT &&1750 new_limits.account_token_ownership_limit <= MAX_TOKEN_OWNERSHIP && 1751 new_limits.sponsored_data_size <= chain_limits.custom_data_limit,1752 Error::<T>::CollectionLimitBoundsExceeded);17531754 // token_limit check prev1755 ensure!(old_limits.token_limit >= new_limits.token_limit, Error::<T>::CollectionTokenLimitExceeded);1756 ensure!(new_limits.token_limit > 0, Error::<T>::CollectionTokenLimitExceeded);17571758 ensure!(1759 (old_limits.owner_can_transfer || !new_limits.owner_can_transfer) &&1760 (old_limits.owner_can_destroy || !new_limits.owner_can_destroy),1761 Error::<T>::OwnerPermissionsCantBeReverted,1762 );17631764 target_collection.limits = new_limits;1765 Self::save_collection(target_collection);17661767 Ok(())1768 } 1769 }1770}17711772impl<T: Config> Module<T> {17731774 pub fn transfer_internal(sender: T::AccountId, recipient: T::AccountId, target_collection: &CollectionHandle<T>, item_id: TokenId, value: u128) -> DispatchResult {1775 // Limits check1776 Self::is_correct_transfer(target_collection, &recipient)?;17771778 // Transfer permissions check1779 ensure!(Self::is_item_owner(sender.clone(), target_collection, item_id) ||1780 Self::is_owner_or_admin_permissions(target_collection, sender.clone()),1781 Error::<T>::NoPermission);17821783 if target_collection.access == AccessMode::WhiteList {1784 Self::check_white_list(target_collection, &sender)?;1785 Self::check_white_list(target_collection, &recipient)?;1786 }17871788 match target_collection.mode1789 {1790 CollectionMode::NFT => Self::transfer_nft(target_collection, item_id, sender.clone(), recipient.clone())?,1791 CollectionMode::Fungible(_) => Self::transfer_fungible(target_collection, value, &sender, &recipient)?,1792 CollectionMode::ReFungible => Self::transfer_refungible(target_collection, item_id, value, sender.clone(), recipient.clone())?,1793 _ => ()1794 };17951796 Self::deposit_event(RawEvent::Transfer(target_collection.id, item_id, sender, recipient, value));17971798 Ok(())1799 }180018011802 fn is_correct_transfer(collection: &CollectionHandle<T>, recipient: &T::AccountId) -> DispatchResult {1803 let collection_id = collection.id;18041805 // check token limit and account token limit1806 let account_items: u32 = <AddressTokens<T>>::get(collection_id, recipient).len() as u32;1807 ensure!(collection.limits.account_token_ownership_limit > account_items, Error::<T>::AccountTokenLimitExceeded);1808 1809 Ok(())1810 }18111812 fn can_create_items_in_collection(collection: &CollectionHandle<T>, sender: &T::AccountId, owner: &T::AccountId, amount: u32) -> DispatchResult {1813 let collection_id = collection.id;18141815 // check token limit and account token limit1816 let total_items: u32 = ItemListIndex::get(collection_id)1817 .checked_add(amount)1818 .ok_or(Error::<T>::CollectionTokenLimitExceeded)?;1819 let account_items: u32 = (<AddressTokens<T>>::get(collection_id, owner).len() as u32)1820 .checked_add(amount)1821 .ok_or(Error::<T>::AccountTokenLimitExceeded)?;1822 ensure!(collection.limits.token_limit >= total_items, Error::<T>::CollectionTokenLimitExceeded);1823 ensure!(collection.limits.account_token_ownership_limit >= account_items, Error::<T>::AccountTokenLimitExceeded);18241825 if !Self::is_owner_or_admin_permissions(collection, sender.clone()) {1826 ensure!(collection.mint_mode == true, Error::<T>::PublicMintingNotAllowed);1827 Self::check_white_list(collection, owner)?;1828 Self::check_white_list(collection, sender)?;1829 }18301831 Ok(())1832 }18331834 fn validate_create_item_args(target_collection: &CollectionHandle<T>, data: &CreateItemData) -> DispatchResult {1835 match target_collection.mode1836 {1837 CollectionMode::NFT => {1838 if let CreateItemData::NFT(data) = data {1839 // check sizes1840 ensure!(ChainLimit::get().custom_data_limit >= data.const_data.len() as u32, Error::<T>::TokenConstDataLimitExceeded);1841 ensure!(ChainLimit::get().custom_data_limit >= data.variable_data.len() as u32, Error::<T>::TokenVariableDataLimitExceeded);1842 } else {1843 fail!(Error::<T>::NotNftDataUsedToMintNftCollectionToken);1844 }1845 },1846 CollectionMode::Fungible(_) => {1847 if let CreateItemData::Fungible(_) = data {1848 } else {1849 fail!(Error::<T>::NotFungibleDataUsedToMintFungibleCollectionToken);1850 }1851 },1852 CollectionMode::ReFungible => {1853 if let CreateItemData::ReFungible(data) = data {18541855 // check sizes1856 ensure!(ChainLimit::get().custom_data_limit >= data.const_data.len() as u32, Error::<T>::TokenConstDataLimitExceeded);1857 ensure!(ChainLimit::get().custom_data_limit >= data.variable_data.len() as u32, Error::<T>::TokenVariableDataLimitExceeded);18581859 // Check refungibility limits1860 ensure!(data.pieces <= MAX_REFUNGIBLE_PIECES, Error::<T>::WrongRefungiblePieces);1861 ensure!(data.pieces > 0, Error::<T>::WrongRefungiblePieces);1862 } else {1863 fail!(Error::<T>::NotReFungibleDataUsedToMintReFungibleCollectionToken);1864 }1865 },1866 _ => { fail!(Error::<T>::UnexpectedCollectionType); }1867 };18681869 Ok(())1870 }18711872 fn create_item_no_validation(collection: &CollectionHandle<T>, owner: T::AccountId, data: CreateItemData) -> DispatchResult {1873 match data1874 {1875 CreateItemData::NFT(data) => {1876 let item = NftItemType {1877 owner: owner.clone(),1878 const_data: data.const_data,1879 variable_data: data.variable_data1880 };18811882 Self::add_nft_item(collection, item)?;1883 },1884 CreateItemData::Fungible(data) => {1885 Self::add_fungible_item(collection, &owner, data.value)?;1886 },1887 CreateItemData::ReFungible(data) => {1888 let mut owner_list = Vec::new();1889 owner_list.push(Ownership {owner: owner.clone(), fraction: data.pieces});18901891 let item = ReFungibleItemType {1892 owner: owner_list,1893 const_data: data.const_data,1894 variable_data: data.variable_data1895 };18961897 Self::add_refungible_item(collection, item)?;1898 }1899 };19001901 Ok(())1902 }19031904 fn add_fungible_item(collection: &CollectionHandle<T>, owner: &T::AccountId, value: u128) -> DispatchResult {1905 let collection_id = collection.id;19061907 // Does new owner already have an account?1908 let balance: u128 = <FungibleItemList<T>>::get(collection_id, owner).value;19091910 // Mint 1911 let item = FungibleItemType {1912 value: balance.checked_add(value).ok_or(Error::<T>::NumOverflow)?,1913 };1914 <FungibleItemList<T>>::insert(collection_id, (*owner).clone(), item);19151916 // Update balance1917 let new_balance = <Balance<T>>::get(collection_id, owner)1918 .checked_add(value)1919 .ok_or(Error::<T>::NumOverflow)?;1920 <Balance<T>>::insert(collection_id, (*owner).clone(), new_balance);19211922 Self::deposit_event(RawEvent::ItemCreated(collection_id, 0, owner.clone()));1923 Ok(())1924 }19251926 fn add_refungible_item(collection: &CollectionHandle<T>, item: ReFungibleItemType<T::AccountId>) -> DispatchResult {1927 let collection_id = collection.id;19281929 let current_index = <ItemListIndex>::get(collection_id)1930 .checked_add(1)1931 .ok_or(Error::<T>::NumOverflow)?;1932 let itemcopy = item.clone();19331934 ensure!(1935 item.owner.len() == 1,1936 Error::<T>::BadCreateRefungibleCall,1937 );1938 let item_owner = item.owner.first().expect("only one owner is defined");19391940 let value = item_owner.fraction;1941 let owner = item_owner.owner.clone();19421943 Self::add_token_index(collection_id, current_index, &owner)?;19441945 <ItemListIndex>::insert(collection_id, current_index);1946 <ReFungibleItemList<T>>::insert(collection_id, current_index, itemcopy);19471948 // Update balance1949 let new_balance = <Balance<T>>::get(collection_id, &owner)1950 .checked_add(value)1951 .ok_or(Error::<T>::NumOverflow)?;1952 <Balance<T>>::insert(collection_id, owner.clone(), new_balance);19531954 Self::deposit_event(RawEvent::ItemCreated(collection_id, current_index, owner));1955 Ok(())1956 }19571958 fn add_nft_item(collection: &CollectionHandle<T>, item: NftItemType<T::AccountId>) -> DispatchResult {1959 let collection_id = collection.id;19601961 let current_index = <ItemListIndex>::get(collection_id)1962 .checked_add(1)1963 .ok_or(Error::<T>::NumOverflow)?;19641965 let item_owner = item.owner.clone();1966 Self::add_token_index(collection_id, current_index, &item.owner)?;19671968 <ItemListIndex>::insert(collection_id, current_index);1969 <NftItemList<T>>::insert(collection_id, current_index, item);19701971 // Update balance1972 let new_balance = <Balance<T>>::get(collection_id, item_owner.clone())1973 .checked_add(1)1974 .ok_or(Error::<T>::NumOverflow)?;1975 <Balance<T>>::insert(collection_id, item_owner.clone(), new_balance);19761977 Self::deposit_event(RawEvent::ItemCreated(collection_id, current_index, item_owner));1978 Ok(())1979 }19801981 fn burn_refungible_item(1982 collection: &CollectionHandle<T>,1983 item_id: TokenId,1984 owner: &T::AccountId,1985 ) -> DispatchResult {1986 let collection_id = collection.id;19871988 let mut token = <ReFungibleItemList<T>>::get(collection_id, item_id)1989 .ok_or(Error::<T>::TokenNotFound)?;1990 let rft_balance = token1991 .owner1992 .iter()1993 .find(|&i| i.owner == *owner)1994 .ok_or(Error::<T>::TokenNotFound)?;1995 Self::remove_token_index(collection_id, item_id, owner)?;19961997 // update balance1998 let new_balance = <Balance<T>>::get(collection_id, rft_balance.owner.clone())1999 .checked_sub(rft_balance.fraction)2000 .ok_or(Error::<T>::NumOverflow)?;2001 <Balance<T>>::insert(collection_id, rft_balance.owner.clone(), new_balance);20022003 // Re-create owners list with sender removed2004 let index = token2005 .owner2006 .iter()2007 .position(|i| i.owner == *owner)2008 .expect("owned item is exists");2009 token.owner.remove(index);2010 let owner_count = token.owner.len();20112012 // Burn the token completely if this was the last (only) owner2013 if owner_count == 0 {2014 <ReFungibleItemList<T>>::remove(collection_id, item_id);2015 <VariableMetaDataBasket<T>>::remove(collection_id, item_id);2016 }2017 else {2018 <ReFungibleItemList<T>>::insert(collection_id, item_id, token);2019 }20202021 Ok(())2022 }20232024 fn burn_nft_item(collection: &CollectionHandle<T>, item_id: TokenId) -> DispatchResult {2025 let collection_id = collection.id;20262027 let item = <NftItemList<T>>::get(collection_id, item_id)2028 .ok_or(Error::<T>::TokenNotFound)?;2029 Self::remove_token_index(collection_id, item_id, &item.owner)?;20302031 // update balance2032 let new_balance = <Balance<T>>::get(collection_id, &item.owner)2033 .checked_sub(1)2034 .ok_or(Error::<T>::NumOverflow)?;2035 <Balance<T>>::insert(collection_id, item.owner.clone(), new_balance);2036 <NftItemList<T>>::remove(collection_id, item_id);2037 <VariableMetaDataBasket<T>>::remove(collection_id, item_id);20382039 Ok(())2040 }20412042 fn burn_fungible_item(owner: &T::AccountId, collection: &CollectionHandle<T>, value: u128) -> DispatchResult {2043 let collection_id = collection.id;20442045 let mut balance = <FungibleItemList<T>>::get(collection_id, owner);2046 ensure!(balance.value >= value, Error::<T>::TokenValueNotEnough);20472048 // update balance2049 let new_balance = <Balance<T>>::get(collection_id, owner)2050 .checked_sub(value)2051 .ok_or(Error::<T>::NumOverflow)?;2052 <Balance<T>>::insert(collection_id, (*owner).clone(), new_balance);20532054 if balance.value - value > 0 {2055 balance.value -= value;2056 <FungibleItemList<T>>::insert(collection_id, (*owner).clone(), balance);2057 }2058 else {2059 <FungibleItemList<T>>::remove(collection_id, owner);2060 }20612062 Ok(())2063 }20642065 pub fn get_collection(collection_id: CollectionId) -> Result<CollectionHandle<T>, sp_runtime::DispatchError> {2066 Ok(<CollectionById<T>>::get(collection_id)2067 .map(|collection| CollectionHandle {2068 id: collection_id,2069 collection2070 })2071 .ok_or(Error::<T>::CollectionNotFound)?)2072 }20732074 fn save_collection(collection: CollectionHandle<T>) {2075 <CollectionById<T>>::insert(collection.id, collection.collection);2076 }20772078 fn check_owner_permissions(target_collection: &CollectionHandle<T>, subject: T::AccountId) -> DispatchResult {2079 ensure!(2080 subject == target_collection.owner,2081 Error::<T>::NoPermission2082 );20832084 Ok(())2085 }20862087 fn is_owner_or_admin_permissions(collection: &CollectionHandle<T>, subject: T::AccountId) -> bool {2088 subject == collection.owner || <AdminList<T>>::get(collection.id).contains(&subject)2089 }20902091 fn check_owner_or_admin_permissions(2092 collection: &CollectionHandle<T>,2093 subject: T::AccountId,2094 ) -> DispatchResult {2095 ensure!(Self::is_owner_or_admin_permissions(collection, subject), Error::<T>::NoPermission);20962097 Ok(())2098 }20992100 fn owned_amount(2101 subject: T::AccountId,2102 target_collection: &CollectionHandle<T>,2103 item_id: TokenId,2104 ) -> Option<u128> {2105 let collection_id = target_collection.id;21062107 match target_collection.mode {2108 CollectionMode::NFT => (<NftItemList<T>>::get(collection_id, item_id)?.owner == subject)2109 .then(|| 1),2110 CollectionMode::Fungible(_) => Some(<FungibleItemList<T>>::get(collection_id, &subject)2111 .value),2112 CollectionMode::ReFungible => <ReFungibleItemList<T>>::get(collection_id, item_id)?2113 .owner2114 .iter()2115 .find(|i| i.owner == subject)2116 .map(|i| i.fraction),2117 CollectionMode::Invalid => None,2118 }2119 }21202121 fn is_item_owner(subject: T::AccountId, target_collection: &CollectionHandle<T>, item_id: TokenId) -> bool {2122 match target_collection.mode {2123 CollectionMode::Fungible(_) => true,2124 _ => Self::owned_amount(subject, target_collection, item_id).is_some(),2125 }2126 }21272128 fn check_white_list(collection: &CollectionHandle<T>, address: &T::AccountId) -> DispatchResult {2129 let collection_id = collection.id;21302131 let mes = Error::<T>::AddresNotInWhiteList;2132 ensure!(<WhiteList<T>>::contains_key(collection_id, address), mes);21332134 Ok(())2135 }21362137 /// Check if token exists. In case of Fungible, check if there is an entry for 2138 /// the owner in fungible balances double map2139 fn token_exists(2140 target_collection: &CollectionHandle<T>,2141 item_id: TokenId,2142 ) -> DispatchResult {2143 let collection_id = target_collection.id;2144 let exists = match target_collection.mode2145 {2146 CollectionMode::NFT => <NftItemList<T>>::contains_key(collection_id, item_id),2147 CollectionMode::Fungible(_) => true,2148 CollectionMode::ReFungible => <ReFungibleItemList<T>>::contains_key(collection_id, item_id),2149 _ => false2150 };21512152 ensure!(exists == true, Error::<T>::TokenNotFound);2153 Ok(())2154 }21552156 fn transfer_fungible(2157 collection: &CollectionHandle<T>,2158 value: u128,2159 owner: &T::AccountId,2160 recipient: &T::AccountId,2161 ) -> DispatchResult {2162 let collection_id = collection.id;21632164 let mut balance = <FungibleItemList<T>>::get(collection_id, owner);2165 ensure!(balance.value >= value, Error::<T>::TokenValueTooLow);21662167 // Send balance to recipient (updates balanceOf of recipient)2168 Self::add_fungible_item(collection, recipient, value)?;21692170 // update balanceOf of sender2171 <Balance<T>>::insert(collection_id, (*owner).clone(), balance.value - value);21722173 // Reduce or remove sender2174 if balance.value == value {2175 <FungibleItemList<T>>::remove(collection_id, owner);2176 }2177 else {2178 balance.value -= value;2179 <FungibleItemList<T>>::insert(collection_id, (*owner).clone(), balance);2180 }21812182 Ok(())2183 }21842185 fn transfer_refungible(2186 collection: &CollectionHandle<T>,2187 item_id: TokenId,2188 value: u128,2189 owner: T::AccountId,2190 new_owner: T::AccountId,2191 ) -> DispatchResult {2192 let collection_id = collection.id;2193 let full_item = <ReFungibleItemList<T>>::get(collection_id, item_id)2194 .ok_or(Error::<T>::TokenNotFound)?;21952196 let item = full_item2197 .owner2198 .iter()2199 .filter(|i| i.owner == owner)2200 .next()2201 .ok_or(Error::<T>::TokenNotFound)?;2202 let amount = item.fraction;22032204 ensure!(amount >= value, Error::<T>::TokenValueTooLow);22052206 // update balance2207 let balance_old_owner = <Balance<T>>::get(collection_id, item.owner.clone())2208 .checked_sub(value)2209 .ok_or(Error::<T>::NumOverflow)?;2210 <Balance<T>>::insert(collection_id, item.owner.clone(), balance_old_owner);22112212 let balance_new_owner = <Balance<T>>::get(collection_id, new_owner.clone())2213 .checked_add(value)2214 .ok_or(Error::<T>::NumOverflow)?;2215 <Balance<T>>::insert(collection_id, new_owner.clone(), balance_new_owner);22162217 let old_owner = item.owner.clone();2218 let new_owner_has_account = full_item.owner.iter().any(|i| i.owner == new_owner);22192220 // transfer2221 if amount == value && !new_owner_has_account {2222 // change owner2223 // new owner do not have account2224 let mut new_full_item = full_item.clone();2225 new_full_item2226 .owner2227 .iter_mut()2228 .find(|i| i.owner == owner)2229 .expect("old owner does present in refungible")2230 .owner = new_owner.clone();2231 <ReFungibleItemList<T>>::insert(collection_id, item_id, new_full_item);22322233 // update index collection2234 Self::move_token_index(collection_id, item_id, &old_owner, &new_owner)?;2235 } else {2236 let mut new_full_item = full_item.clone();2237 new_full_item2238 .owner2239 .iter_mut()2240 .find(|i| i.owner == owner)2241 .expect("old owner does present in refungible")2242 .fraction -= value;22432244 // separate amount2245 if new_owner_has_account {2246 // new owner has account2247 new_full_item2248 .owner2249 .iter_mut()2250 .find(|i| i.owner == new_owner)2251 .expect("new owner has account")2252 .fraction += value;2253 } else {2254 // new owner do not have account2255 new_full_item.owner.push(Ownership {2256 owner: new_owner.clone(),2257 fraction: value,2258 });2259 Self::add_token_index(collection_id, item_id, &new_owner)?;2260 }22612262 <ReFungibleItemList<T>>::insert(collection_id, item_id, new_full_item);2263 }22642265 Ok(())2266 }22672268 fn transfer_nft(2269 collection: &CollectionHandle<T>,2270 item_id: TokenId,2271 sender: T::AccountId,2272 new_owner: T::AccountId,2273 ) -> DispatchResult {2274 let collection_id = collection.id;2275 let mut item = <NftItemList<T>>::get(collection_id, item_id)2276 .ok_or(Error::<T>::TokenNotFound)?;22772278 ensure!(2279 sender == item.owner,2280 Error::<T>::MustBeTokenOwner2281 );22822283 // update balance2284 let balance_old_owner = <Balance<T>>::get(collection_id, item.owner.clone())2285 .checked_sub(1)2286 .ok_or(Error::<T>::NumOverflow)?;2287 <Balance<T>>::insert(collection_id, item.owner.clone(), balance_old_owner);22882289 let balancenew_owner = <Balance<T>>::get(collection_id, new_owner.clone())2290 .checked_add(1)2291 .ok_or(Error::<T>::NumOverflow)?;2292 <Balance<T>>::insert(collection_id, new_owner.clone(), balancenew_owner);22932294 // change owner2295 let old_owner = item.owner.clone();2296 item.owner = new_owner.clone();2297 <NftItemList<T>>::insert(collection_id, item_id, item);22982299 // update index collection2300 Self::move_token_index(collection_id, item_id, &old_owner, &new_owner)?;23012302 Ok(())2303 }2304 2305 fn set_re_fungible_variable_data(2306 collection: &CollectionHandle<T>,2307 item_id: TokenId,2308 data: Vec<u8>2309 ) -> DispatchResult {2310 let collection_id = collection.id;2311 let mut item = <ReFungibleItemList<T>>::get(collection_id, item_id)2312 .ok_or(Error::<T>::TokenNotFound)?;23132314 item.variable_data = data;23152316 <ReFungibleItemList<T>>::insert(collection_id, item_id, item);23172318 Ok(())2319 }23202321 fn set_nft_variable_data(2322 collection: &CollectionHandle<T>,2323 item_id: TokenId,2324 data: Vec<u8>2325 ) -> DispatchResult {2326 let collection_id = collection.id;2327 let mut item = <NftItemList<T>>::get(collection_id, item_id)2328 .ok_or(Error::<T>::TokenNotFound)?;2329 2330 item.variable_data = data;23312332 <NftItemList<T>>::insert(collection_id, item_id, item);2333 2334 Ok(())2335 }23362337 fn init_collection(item: &Collection<T>) {2338 // check params2339 assert!(2340 item.decimal_points <= MAX_DECIMAL_POINTS,2341 "decimal_points parameter must be lower than MAX_DECIMAL_POINTS"2342 );2343 assert!(2344 item.name.len() <= 64,2345 "Collection name can not be longer than 63 char"2346 );2347 assert!(2348 item.name.len() <= 256,2349 "Collection description can not be longer than 255 char"2350 );2351 assert!(2352 item.token_prefix.len() <= 16,2353 "Token prefix can not be longer than 15 char"2354 );23552356 // Generate next collection ID2357 let next_id = CreatedCollectionCount::get()2358 .checked_add(1)2359 .unwrap();23602361 CreatedCollectionCount::put(next_id);2362 }23632364 fn init_nft_token(collection_id: CollectionId, item: &NftItemType<T::AccountId>) {2365 let current_index = <ItemListIndex>::get(collection_id)2366 .checked_add(1)2367 .unwrap();23682369 let item_owner = item.owner.clone();2370 Self::add_token_index(collection_id, current_index, &item.owner).unwrap();23712372 <ItemListIndex>::insert(collection_id, current_index);23732374 // Update balance2375 let new_balance = <Balance<T>>::get(collection_id, &item_owner)2376 .checked_add(1)2377 .unwrap();2378 <Balance<T>>::insert(collection_id, item_owner.clone(), new_balance);2379 }23802381 fn init_fungible_token(collection_id: CollectionId, owner: &T::AccountId, item: &FungibleItemType) {2382 let current_index = <ItemListIndex>::get(collection_id)2383 .checked_add(1)2384 .unwrap();23852386 Self::add_token_index(collection_id, current_index, owner).unwrap();23872388 <ItemListIndex>::insert(collection_id, current_index);23892390 // Update balance2391 let new_balance = <Balance<T>>::get(collection_id, owner)2392 .checked_add(item.value)2393 .unwrap();2394 <Balance<T>>::insert(collection_id, (*owner).clone(), new_balance);2395 }23962397 fn init_refungible_token(collection_id: CollectionId, item: &ReFungibleItemType<T::AccountId>) {2398 let current_index = <ItemListIndex>::get(collection_id)2399 .checked_add(1)2400 .unwrap();24012402 let value = item.owner.first().unwrap().fraction;2403 let owner = item.owner.first().unwrap().owner.clone();24042405 Self::add_token_index(collection_id, current_index, &owner).unwrap();24062407 <ItemListIndex>::insert(collection_id, current_index);24082409 // Update balance2410 let new_balance = <Balance<T>>::get(collection_id, &owner)2411 .checked_add(value)2412 .unwrap();2413 <Balance<T>>::insert(collection_id, owner.clone(), new_balance);2414 }24152416 fn add_token_index(collection_id: CollectionId, item_index: TokenId, owner: &T::AccountId) -> DispatchResult {2417 // add to account limit2418 if <AccountItemCount<T>>::contains_key(owner) {24192420 // bound Owned tokens by a single address2421 let count = <AccountItemCount<T>>::get(owner);2422 ensure!(count < ChainLimit::get().account_token_ownership_limit, Error::<T>::AddressOwnershipLimitExceeded);24232424 <AccountItemCount<T>>::insert(owner.clone(), count2425 .checked_add(1)2426 .ok_or(Error::<T>::NumOverflow)?);2427 }2428 else {2429 <AccountItemCount<T>>::insert(owner.clone(), 1);2430 }24312432 let list_exists = <AddressTokens<T>>::contains_key(collection_id, owner);2433 if list_exists {2434 let mut list = <AddressTokens<T>>::get(collection_id, owner);2435 let item_contains = list.contains(&item_index.clone());24362437 if !item_contains {2438 list.push(item_index.clone());2439 }24402441 <AddressTokens<T>>::insert(collection_id, owner.clone(), list);2442 } else {2443 let mut itm = Vec::new();2444 itm.push(item_index.clone());2445 <AddressTokens<T>>::insert(collection_id, owner.clone(), itm);2446 }24472448 Ok(())2449 }24502451 fn remove_token_index(2452 collection_id: CollectionId,2453 item_index: TokenId,2454 owner: &T::AccountId,2455 ) -> DispatchResult {24562457 // update counter2458 <AccountItemCount<T>>::insert(owner.clone(), 2459 <AccountItemCount<T>>::get(owner)2460 .checked_sub(1)2461 .ok_or(Error::<T>::NumOverflow)?);246224632464 let list_exists = <AddressTokens<T>>::contains_key(collection_id, owner);2465 if list_exists {2466 let mut list = <AddressTokens<T>>::get(collection_id, owner);2467 let item_contains = list.contains(&item_index.clone());24682469 if item_contains {2470 list.retain(|&item| item != item_index);2471 <AddressTokens<T>>::insert(collection_id, owner.clone(), list);2472 }2473 }24742475 Ok(())2476 }24772478 fn move_token_index(2479 collection_id: CollectionId,2480 item_index: TokenId,2481 old_owner: &T::AccountId,2482 new_owner: &T::AccountId,2483 ) -> DispatchResult {2484 Self::remove_token_index(collection_id, item_index, old_owner)?;2485 Self::add_token_index(collection_id, item_index, new_owner)?;24862487 Ok(())2488 }2489 2490 fn ensure_contract_owned(account: T::AccountId, contract: &T::AccountId) -> DispatchResult {2491 ensure!(<ContractOwner<T>>::get(contract) == Some(account), Error::<T>::NoPermission);24922493 Ok(())2494 }2495}24962497////////////////////////////////////////////////////////////////////////////////////////////////////2498// Economic models2499// #region25002501/// Fee multiplier.2502pub type Multiplier = FixedU128;25032504type BalanceOf<T> = <<T as pallet_transaction_payment::Config>::OnChargeTransaction as pallet_transaction_payment::OnChargeTransaction<T>>::Balance;25052506/// Require the transactor pay for themselves and maybe include a tip to gain additional priority2507/// in the queue.2508#[derive(Encode, Decode, Clone, Eq, PartialEq)]2509pub struct ChargeTransactionPayment<T: Config>(#[codec(compact)] BalanceOf<T>);25102511impl<T: Config + Send + Sync> sp_std::fmt::Debug 2512 for ChargeTransactionPayment<T>2513{2514 #[cfg(feature = "std")]2515 fn fmt(&self, f: &mut sp_std::fmt::Formatter) -> sp_std::fmt::Result {2516 write!(f, "ChargeTransactionPayment<{:?}>", self.0)2517 }2518 #[cfg(not(feature = "std"))]2519 fn fmt(&self, _: &mut sp_std::fmt::Formatter) -> sp_std::fmt::Result {2520 Ok(())2521 }2522}25232524impl<T: Config> ChargeTransactionPayment<T>2525where2526 T::Call: Dispatchable<Info=DispatchInfo, PostInfo=PostDispatchInfo> + IsSubType<Call<T>> + IsSubType<pallet_contracts::Call<T>>,2527 BalanceOf<T>: Send + Sync + From<u64> + FixedPointOperand,2528 T::AccountId: AsRef<[u8]>,2529 T::AccountId: UncheckedFrom<T::Hash>,2530{2531 fn traditional_fee(2532 len: usize,2533 info: &DispatchInfoOf<T::Call>,2534 tip: BalanceOf<T>,2535 ) -> BalanceOf<T>2536 where2537 T::Call: Dispatchable<Info = DispatchInfo>,2538 {2539 <pallet_transaction_payment::Module<T>>::compute_fee(len as u32, info, tip)2540 }25412542 fn get_priority(len: usize, info: &DispatchInfoOf<T::Call>, final_fee: BalanceOf<T>) -> TransactionPriority {2543 let weight_saturation = T::BlockWeights::get().max_block / info.weight.max(1);2544 let max_block_length = *T::BlockLength::get().max.get(DispatchClass::Normal);2545 let len_saturation = max_block_length as u64 / (len as u64).max(1);2546 let coefficient: BalanceOf<T> = weight_saturation2547 .min(len_saturation)2548 .saturated_into::<BalanceOf<T>>();2549 final_fee2550 .saturating_mul(coefficient)2551 .saturated_into::<TransactionPriority>()2552 }25532554 fn withdraw_fee(2555 &self,2556 who: &T::AccountId,2557 call: &T::Call,2558 info: &DispatchInfoOf<T::Call>,2559 len: usize,2560 ) -> Result<2561 (2562 BalanceOf<T>,2563 <<T as pallet_transaction_payment::Config>::OnChargeTransaction as pallet_transaction_payment::OnChargeTransaction<T>>::LiquidityInfo,2564 ),2565 TransactionValidityError,2566 > {2567 let tip = self.0;25682569 let fee = Self::traditional_fee(len, info, tip);25702571 // Only mess with balances if fee is not zero.2572 if fee.is_zero() {2573 return <<T as pallet_transaction_payment::Config>::OnChargeTransaction as pallet_transaction_payment::OnChargeTransaction<T>>::withdraw_fee(who, call, info, fee, tip)2574 .map(|i| (fee, i));2575 }25762577 // Determine who is paying transaction fee based on ecnomic model2578 // Parse call to extract collection ID and access collection sponsor2579 let mut sponsor: Option<T::AccountId> = (|| match IsSubType::<Call<T>>::is_sub_type(call) {2580 Some(Call::create_item(collection_id, _owner, _properties)) => {2581 let collection = <CollectionById<T>>::get(collection_id)?;25822583 // sponsor timeout2584 let block_number = <system::Module<T>>::block_number() as T::BlockNumber;25852586 let limit = collection.limits.sponsor_transfer_timeout;2587 if <CreateItemBasket<T>>::contains_key((collection_id, &who)) {2588 let last_tx_block = <CreateItemBasket<T>>::get((collection_id, &who));2589 let limit_time = last_tx_block + limit.into();2590 if block_number <= limit_time {2591 return None;2592 }2593 }2594 <CreateItemBasket<T>>::insert((collection_id, who.clone()), block_number);25952596 // check free create limit2597 if collection.limits.sponsored_data_size >= (_properties.len() as u32) {2598 collection.sponsorship.sponsor()2599 .cloned()2600 } else {2601 None2602 }2603 }2604 Some(Call::transfer(_new_owner, collection_id, item_id, _value)) => {2605 let collection = <CollectionById<T>>::get(collection_id)?;2606 2607 let mut sponsor_transfer = false;2608 if collection.sponsorship.confirmed() {26092610 let collection_limits = collection.limits;2611 let collection_mode = collection.mode;2612 2613 // sponsor timeout2614 let block_number = <system::Module<T>>::block_number() as T::BlockNumber;2615 sponsor_transfer = match collection_mode {2616 CollectionMode::NFT => {2617 2618 // get correct limit2619 let limit: u32 = if collection_limits.sponsor_transfer_timeout > 0 {2620 collection_limits.sponsor_transfer_timeout2621 } else {2622 ChainLimit::get().nft_sponsor_transfer_timeout2623 };2624 2625 let mut sponsored = true;2626 if <NftTransferBasket<T>>::contains_key(collection_id, item_id) {2627 let last_tx_block = <NftTransferBasket<T>>::get(collection_id, item_id);2628 let limit_time = last_tx_block + limit.into();2629 if block_number <= limit_time {2630 sponsored = false;2631 }2632 }2633 if sponsored {2634 <NftTransferBasket<T>>::insert(collection_id, item_id, block_number);2635 }26362637 sponsored2638 }2639 CollectionMode::Fungible(_) => {2640 2641 // get correct limit2642 let limit: u32 = if collection_limits.sponsor_transfer_timeout > 0 {2643 collection_limits.sponsor_transfer_timeout2644 } else {2645 ChainLimit::get().fungible_sponsor_transfer_timeout2646 };2647 2648 let block_number = <system::Module<T>>::block_number() as T::BlockNumber;2649 let mut sponsored = true;2650 if <FungibleTransferBasket<T>>::contains_key(collection_id, who) {2651 let last_tx_block = <FungibleTransferBasket<T>>::get(collection_id, who);2652 let limit_time = last_tx_block + limit.into();2653 if block_number <= limit_time {2654 sponsored = false;2655 }2656 }2657 if sponsored {2658 <FungibleTransferBasket<T>>::insert(collection_id, who, block_number);2659 }26602661 sponsored2662 }2663 CollectionMode::ReFungible => {2664 2665 // get correct limit2666 let limit: u32 = if collection_limits.sponsor_transfer_timeout > 0 {2667 collection_limits.sponsor_transfer_timeout2668 } else {2669 ChainLimit::get().refungible_sponsor_transfer_timeout2670 };2671 2672 let mut sponsored = true;2673 if <ReFungibleTransferBasket<T>>::contains_key(collection_id, item_id) {2674 let last_tx_block = <ReFungibleTransferBasket<T>>::get(collection_id, item_id);2675 let limit_time = last_tx_block + limit.into();2676 if block_number <= limit_time {2677 sponsored = false;2678 }2679 }2680 if sponsored {2681 <ReFungibleTransferBasket<T>>::insert(collection_id, item_id, block_number);2682 }26832684 sponsored2685 }2686 _ => {2687 false2688 },2689 };2690 }26912692 if !sponsor_transfer {2693 None2694 } else {2695 collection.sponsorship.sponsor()2696 .cloned()2697 }2698 }26992700 Some(Call::set_variable_meta_data(collection_id, item_id, data)) => {2701 let mut sponsor_metadata_changes = false;27022703 let collection = <CollectionById<T>>::get(collection_id)?;27042705 if2706 collection.sponsorship.confirmed() &&2707 // Can't sponsor fungible collection, this tx will be rejected2708 // as invalid2709 !matches!(collection.mode, CollectionMode::Fungible(_)) &&2710 data.len() <= collection.limits.sponsored_data_size as usize2711 {2712 if let Some(rate_limit) = collection.limits.sponsored_data_rate_limit {2713 let block_number = <system::Module<T>>::block_number() as T::BlockNumber;27142715 if <VariableMetaDataBasket<T>>::get(collection_id, item_id)2716 .map(|last_block| block_number - last_block > rate_limit)2717 .unwrap_or(true) 2718 {2719 sponsor_metadata_changes = true;2720 <VariableMetaDataBasket<T>>::insert(collection_id, item_id, block_number);2721 }2722 }2723 }27242725 if !sponsor_metadata_changes {2726 None2727 } else {2728 collection.sponsorship.sponsor().cloned()2729 }2730 }27312732 _ => None,2733 })();27342735 match IsSubType::<pallet_contracts::Call<T>>::is_sub_type(call) {2736 Some(pallet_contracts::Call::call(dest, _value, _gas_limit, _data)) => {27372738 let called_contract: T::AccountId = T::Lookup::lookup((*dest).clone()).unwrap_or(T::AccountId::default());27392740 let owned_contract = <ContractOwner<T>>::get(called_contract.clone()).as_ref() == Some(who);2741 let white_list_enabled = <ContractWhiteListEnabled<T>>::contains_key(called_contract.clone());2742 2743 if !owned_contract && white_list_enabled {2744 if !<ContractWhiteList<T>>::contains_key(called_contract.clone(), who) {2745 return Err(InvalidTransaction::Call.into());2746 }2747 }2748 },2749 _ => {},2750 }27512752 // Sponsor smart contracts2753 sponsor = sponsor.or_else(|| match IsSubType::<pallet_contracts::Call<T>>::is_sub_type(call) {27542755 // On instantiation: set the contract owner2756 Some(pallet_contracts::Call::instantiate(_endowment, _gas_limit, code_hash, _data, salt)) => {27572758 let new_contract_address = <pallet_contracts::Module<T>>::contract_address(2759 &who,2760 code_hash,2761 salt,2762 );2763 <ContractOwner<T>>::insert(new_contract_address.clone(), who.clone());27642765 None2766 },27672768 // On instantiation with code: set the contract owner2769 Some(pallet_contracts::Call::instantiate_with_code(_endowment, _gas_limit, _code, _data, _salt)) => {27702771 let new_contract_address = <pallet_contracts::Module<T>>::contract_address(2772 &who,2773 &T::Hashing::hash(&_code),2774 _salt,2775 );27762777 <ContractOwner<T>>::insert(new_contract_address.clone(), who.clone());27782779 None2780 }27812782 // When the contract is called, check if the sponsoring is enabled and pay fees from contract endowment if it is2783 Some(pallet_contracts::Call::call(dest, _value, _gas_limit, _data)) => {27842785 let called_contract: T::AccountId = T::Lookup::lookup((*dest).clone()).unwrap_or(T::AccountId::default());27862787 let mut sponsor_transfer = false;2788 if <ContractSponsoringRateLimit<T>>::contains_key(called_contract.clone()) {2789 let last_tx_block = <ContractSponsorBasket<T>>::get((&called_contract, &who));2790 let block_number = <system::Module<T>>::block_number() as T::BlockNumber;2791 let rate_limit = <ContractSponsoringRateLimit<T>>::get(&called_contract);2792 let limit_time = last_tx_block + rate_limit;27932794 if block_number >= limit_time {2795 <ContractSponsorBasket<T>>::insert((called_contract.clone(), who.clone()), block_number);2796 sponsor_transfer = true;2797 }2798 } else {2799 sponsor_transfer = false;2800 }2801 2802 if sponsor_transfer {2803 if <ContractSelfSponsoring<T>>::contains_key(called_contract.clone()) {2804 if <ContractSelfSponsoring<T>>::get(called_contract.clone()) {2805 return Some(called_contract);2806 }2807 }2808 }28092810 None2811 },28122813 _ => None,2814 });28152816 let who_pays_fee = sponsor.unwrap_or_else(|| who.clone());28172818 <<T as pallet_transaction_payment::Config>::OnChargeTransaction as pallet_transaction_payment::OnChargeTransaction<T>>::withdraw_fee(&who_pays_fee, call, info, fee, tip)2819 .map(|i| (fee, i))2820 }2821}282228232824impl<T: Config + Send + Sync> SignedExtension2825 for ChargeTransactionPayment<T>2826where2827 BalanceOf<T>: Send + Sync + From<u64> + FixedPointOperand,2828 T::Call: Dispatchable<Info = DispatchInfo, PostInfo = PostDispatchInfo> + IsSubType<Call<T>> + IsSubType<pallet_contracts::Call<T>>,2829 T::AccountId: AsRef<[u8]>,2830 T::AccountId: UncheckedFrom<T::Hash>,2831{2832 const IDENTIFIER: &'static str = "ChargeTransactionPayment";2833 type AccountId = T::AccountId;2834 type Call = T::Call;2835 type AdditionalSigned = ();2836 type Pre = (2837 // tip2838 BalanceOf<T>,2839 // who pays fee2840 Self::AccountId,2841 // imbalance resulting from withdrawing the fee2842 <<T as pallet_transaction_payment::Config>::OnChargeTransaction as pallet_transaction_payment::OnChargeTransaction<T>>::LiquidityInfo,2843 );2844 fn additional_signed(&self) -> sp_std::result::Result<(), TransactionValidityError> {2845 Ok(())2846 }28472848 fn validate(2849 &self,2850 who: &Self::AccountId,2851 call: &Self::Call,2852 info: &DispatchInfoOf<Self::Call>,2853 len: usize,2854 ) -> TransactionValidity {2855 let (fee, _) = self.withdraw_fee(who, call, info, len)?;2856 Ok(ValidTransaction {2857 priority: Self::get_priority(len, info, fee),2858 ..Default::default()2859 })2860 }28612862 fn pre_dispatch(2863 self,2864 who: &Self::AccountId,2865 call: &Self::Call,2866 info: &DispatchInfoOf<Self::Call>,2867 len: usize,2868 ) -> Result<Self::Pre, TransactionValidityError> {2869 let (_fee, imbalance) = self.withdraw_fee(who, call, info, len)?;2870 Ok((self.0, who.clone(), imbalance))2871 }28722873 fn post_dispatch(2874 pre: Self::Pre,2875 info: &DispatchInfoOf<Self::Call>,2876 post_info: &PostDispatchInfoOf<Self::Call>,2877 len: usize,2878 _result: &DispatchResult,2879 ) -> Result<(), TransactionValidityError> {2880 let (tip, who, imbalance) = pre;2881 let actual_fee = pallet_transaction_payment::Module::<T>::compute_actual_fee(2882 len as u32,2883 info,2884 post_info,2885 tip,2886 );2887 <T as pallet_transaction_payment::Config>::OnChargeTransaction::correct_and_deposit_fee(&who, info, post_info, actual_fee, tip, imbalance)?;2888 Ok(())2889 }2890}28912892// #endregionruntime/src/lib.rsdiffbeforeafterboth--- a/runtime/src/lib.rs
+++ b/runtime/src/lib.rs
@@ -578,6 +578,12 @@
impl pallet_nft::Config for Runtime {
type Event = Event;
type WeightInfo = nft_weights::WeightInfo;
+
+ type EvmWithdrawOrigin = EnsureAddressTruncated;
+ type EvmBackwardsAddressMapping = pallet_nft::MapBackwardsAddressTruncated;
+ type EvmAddressMapping = HashedAddressMapping<Self::Hashing>;
+ type CrossAccountId = pallet_nft::BasicCrossAccountId<Self>;
+
type Currency = Balances;
type CollectionCreationPrice = CollectionCreationPrice;
type TreasuryAccountId = TreasuryAccountId;
runtime_types.jsondiffbeforeafterboth--- a/runtime_types.json
+++ b/runtime_types.json
@@ -1,4 +1,10 @@
{
+ "CrossAccountId": {
+ "_enum": {
+ "substrate": "AccountId",
+ "ethereum": "H160"
+ }
+ },
"AccessMode": {
"_enum": [
"Normal",
@@ -15,31 +21,31 @@
}
},
"Ownership": {
- "Owner": "AccountId",
+ "Owner": "CrossAccountId",
"Fraction": "u128"
},
"FungibleItemType": {
"Value": "u128"
},
"NftItemType": {
- "Owner": "AccountId",
+ "Owner": "CrossAccountId",
"ConstData": "Vec<u8>",
"VariableData": "Vec<u8>"
},
"ReFungibleItemType": {
- "Owner": "Vec<Ownership<AccountId>>",
+ "Owner": "Vec<Ownership<CrossAccountId>>",
"ConstData": "Vec<u8>",
"VariableData": "Vec<u8>"
},
"SponsorshipState": {
"_enum": {
- "Disabled": null,
- "Unconfirmed": "AccountId",
- "Confirmed": "AccountId"
+ "disabled": null,
+ "unconfirmed": "CrossAccountId",
+ "confirmed": "CrossAccountId"
}
},
"Collection": {
- "Owner": "AccountId",
+ "Owner": "CrossAccountId",
"Mode": "CollectionMode",
"Access": "AccessMode",
"DecimalPoints": "DecimalPoints",