1#![cfg_attr(not(feature = "std"), no_std)]23#[cfg(feature = "std")]4pub use std::*;56#[cfg(feature = "std")]7pub use serde::*;89use codec::{Decode, Encode};10pub use frame_support::{11 construct_runtime, decl_event, decl_module, decl_storage, decl_error,12 dispatch::DispatchResult,13 ensure, fail, parameter_types,14 traits::{15 Currency, ExistenceRequirement, Get, Imbalance, KeyOwnerProofSystem, OnUnbalanced,16 Randomness, WithdrawReason,17 },18 weights::{19 constants::{BlockExecutionWeight, ExtrinsicBaseWeight, RocksDbWeight, WEIGHT_PER_SECOND},20 DispatchInfo, GetDispatchInfo, IdentityFee, Pays, PostDispatchInfo, Weight,21 WeightToFeePolynomial,22 },23 IsSubType, StorageValue,24};2526use frame_system::{self as system, ensure_signed, ensure_root};27use sp_runtime::sp_std::prelude::Vec;28use sp_runtime::{29 traits::{30 DispatchInfoOf, Dispatchable, PostDispatchInfoOf, Saturating, SignedExtension, Zero,31 },32 transaction_validity::{33 InvalidTransaction, TransactionValidity, TransactionValidityError, ValidTransaction,34 },35 FixedPointOperand, FixedU128,36};37use pallet_contracts::ContractAddressFor;38use sp_runtime::traits::StaticLookup;3940#[cfg(test)]41mod mock;4243#[cfg(test)]44mod tests;4546mod default_weights;4748495051#[derive(Encode, Decode, Eq, Debug, Clone, PartialEq)]52#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]53pub enum CollectionMode {54 Invalid,55 NFT,56 57 Fungible(u32),58 59 ReFungible(u32),60}6162impl Into<u8> for CollectionMode {63 fn into(self) -> u8 {64 match self {65 CollectionMode::Invalid => 0,66 CollectionMode::NFT => 1,67 CollectionMode::Fungible(_) => 2,68 CollectionMode::ReFungible(_) => 3,69 }70 }71}7273#[derive(Encode, Decode, Eq, Debug, Clone, PartialEq)]74#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]75pub enum AccessMode {76 Normal,77 WhiteList,78}79impl Default for AccessMode {80 fn default() -> Self {81 Self::Normal82 }83}8485impl Default for CollectionMode {86 fn default() -> Self {87 Self::Invalid88 }89}9091#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]92#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]93pub struct Ownership<AccountId> {94 pub owner: AccountId,95 pub fraction: u128,96}9798#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]99#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]100pub struct CollectionType<AccountId> {101 pub owner: AccountId,102 pub mode: CollectionMode,103 pub access: AccessMode,104 pub decimal_points: u32,105 pub name: Vec<u16>, 106 pub description: Vec<u16>, 107 pub token_prefix: Vec<u8>, 108 pub mint_mode: bool,109 pub offchain_schema: Vec<u8>,110 pub sponsor: AccountId, 111 pub unconfirmed_sponsor: AccountId, 112 pub variable_on_chain_schema: Vec<u8>, 113 pub const_on_chain_schema: Vec<u8>, 114}115116#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]117#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]118pub struct NftItemType<AccountId> {119 pub collection: u64,120 pub owner: AccountId,121 pub const_data: Vec<u8>,122 pub variable_data: Vec<u8>,123}124125#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]126#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]127pub struct FungibleItemType<AccountId> {128 pub collection: u64,129 pub owner: AccountId,130 pub value: u128,131}132133#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]134#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]135pub struct ReFungibleItemType<AccountId> {136 pub collection: u64,137 pub owner: Vec<Ownership<AccountId>>,138 pub const_data: Vec<u8>,139 pub variable_data: Vec<u8>,140}141142#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]143#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]144pub struct ApprovePermissions<AccountId> {145 pub approved: AccountId,146 pub amount: u64,147}148149#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]150#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]151pub struct VestingItem<AccountId, Moment> {152 pub sender: AccountId,153 pub recipient: AccountId,154 pub collection_id: u64,155 pub item_id: u64,156 pub amount: u64,157 pub vesting_date: Moment,158}159160#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]161#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]162pub struct BasketItem<AccountId, BlockNumber> {163 pub address: AccountId,164 pub start_block: BlockNumber,165}166167#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]168#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]169pub struct ChainLimits {170 pub collection_numbers_limit: u64,171 pub account_token_ownership_limit: u64,172 pub collections_admins_limit: u64,173 pub custom_data_limit: u32,174175 176 pub nft_sponsor_transfer_timeout: u32,177 pub fungible_sponsor_transfer_timeout: u32,178 pub refungible_sponsor_transfer_timeout: u32,179}180181pub trait WeightInfo {182 fn create_collection() -> Weight;183 fn destroy_collection() -> Weight;184 fn add_to_white_list() -> Weight;185 fn remove_from_white_list() -> Weight;186 fn set_public_access_mode() -> Weight;187 fn set_mint_permission() -> Weight;188 fn change_collection_owner() -> Weight;189 fn add_collection_admin() -> Weight;190 fn remove_collection_admin() -> Weight;191 fn set_collection_sponsor() -> Weight;192 fn confirm_sponsorship() -> Weight;193 fn remove_collection_sponsor() -> Weight;194 fn create_item(s: usize) -> Weight;195 fn burn_item() -> Weight;196 fn transfer() -> Weight;197 fn approve() -> Weight;198 fn transfer_from() -> Weight;199 fn set_offchain_schema() -> Weight;200 fn set_const_on_chain_schema() -> Weight;201 fn set_variable_on_chain_schema() -> Weight;202 fn set_variable_meta_data() -> Weight;203 204}205206#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]207#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]208pub struct CreateNftData {209 pub const_data: Vec<u8>,210 pub variable_data: Vec<u8>,211}212213#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]214#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]215pub struct CreateFungibleData {216}217218#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]219#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]220pub struct CreateReFungibleData {221 pub const_data: Vec<u8>,222 pub variable_data: Vec<u8>,223}224225#[derive(Encode, Decode, Debug, Clone, PartialEq)]226#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]227pub enum CreateItemData {228 NFT(CreateNftData),229 Fungible(CreateFungibleData),230 ReFungible(CreateReFungibleData)231}232233impl CreateItemData {234 pub fn len(&self) -> usize {235 let len = match self {236 CreateItemData::NFT(data) => data.variable_data.len() + data.const_data.len(),237 CreateItemData::ReFungible(data) => data.variable_data.len() + data.const_data.len(),238 _ => 0239 };240 241 return len;242 }243}244245impl From<CreateNftData> for CreateItemData {246 fn from(item: CreateNftData) -> Self {247 CreateItemData::NFT(item)248 }249}250251impl From<CreateReFungibleData> for CreateItemData {252 fn from(item: CreateReFungibleData) -> Self {253 CreateItemData::ReFungible(item)254 }255}256257impl From<CreateFungibleData> for CreateItemData {258 fn from(item: CreateFungibleData) -> Self {259 CreateItemData::Fungible(item)260 }261}262263264decl_error! {265 266 pub enum Error for Module<T: Trait> {267 268 TotalCollectionsLimitExceeded,269 270 CollectionDecimalPointLimitExceeded, 271 272 CollectionNameLimitExceeded, 273 274 CollectionDescriptionLimitExceeded, 275 276 CollectionTokenPrefixLimitExceeded,277 278 CollectionNotFound,279 280 TokenNotFound,281 282 NumOverflow, 283 284 AlreadyAdmin, 285 286 NoPermission,287 288 ConfirmUnsetSponsorFail,289 290 PublicMintingNotAllowed,291 292 MustBeTokenOwner,293 294 TokenValueTooLow,295 296 NftSizeLimitExceeded,297 298 FungibleUnexpectedParam,299 300 ApproveNotFound,301 302 TokenValueNotEnough,303 304 ApproveRequired,305 306 AddresNotInWhiteList,307 308 CollectionAdminsLimitExceeded,309 310 AddressOwnershipLimitExceeded,311 312 EmptyArgument,313 }314}315316pub trait Trait: system::Trait + Sized + transaction_payment::Trait + pallet_contracts::Trait {317 type Event: From<Event<Self>> + Into<<Self as system::Trait>::Event>;318319 320 type WeightInfo: WeightInfo;321}322323#[cfg(feature = "runtime-benchmarks")]324mod benchmarking;325326327328decl_storage! {329 trait Store for Module<T: Trait> as Nft {330331 332 NextCollectionID: u64;333 CreatedCollectionCount: u64;334 ChainVersion: u64;335 ItemListIndex: map hasher(blake2_128_concat) u64 => u64;336337 338 pub ChainLimit get(fn chain_limit) config(): ChainLimits;339340 341 CollectionCount: u64;342 pub AccountItemCount get(fn account_item_count): map hasher(identity) T::AccountId => u64;343344 345 pub Collection get(fn collection) config(): map hasher(identity) u64 => CollectionType<T::AccountId>;346 pub AdminList get(fn admin_list_collection): map hasher(identity) u64 => Vec<T::AccountId>;347 pub WhiteList get(fn white_list): map hasher(identity) u64 => Vec<T::AccountId>;348349 350 pub Balance get(fn balance_count): double_map hasher(blake2_128_concat) u64, hasher(blake2_128_concat) T::AccountId => u64;351352 353 pub ApprovedList get(fn approved): double_map hasher(blake2_128_concat) u64, hasher(blake2_128_concat) (u64, T::AccountId) => Vec<ApprovePermissions<T::AccountId>>;354355 356 pub NftItemList get(fn nft_item_id) config(): double_map hasher(blake2_128_concat) u64, hasher(blake2_128_concat) u64 => NftItemType<T::AccountId>;357 pub FungibleItemList get(fn fungible_item_id) config(): double_map hasher(blake2_128_concat) u64, hasher(blake2_128_concat) u64 => FungibleItemType<T::AccountId>;358 pub ReFungibleItemList get(fn refungible_item_id) config(): double_map hasher(blake2_128_concat) u64, hasher(blake2_128_concat) u64 => ReFungibleItemType<T::AccountId>;359360 361 pub AddressTokens get(fn address_tokens): double_map hasher(blake2_128_concat) u64, hasher(blake2_128_concat) T::AccountId => Vec<u64>;362363 364 pub NftTransferBasket get(fn nft_transfer_basket): double_map hasher(blake2_128_concat) u64, hasher(blake2_128_concat) u64 => T::BlockNumber;365 pub FungibleTransferBasket get(fn fungible_transfer_basket): double_map hasher(blake2_128_concat) u64, hasher(blake2_128_concat) u64 => Vec<BasketItem<T::AccountId, T::BlockNumber>>;366 pub ReFungibleTransferBasket get(fn refungible_transfer_basket): double_map hasher(blake2_128_concat) u64, hasher(blake2_128_concat) u64 => T::BlockNumber;367368 369 pub ContractOwner get(fn contract_owner): map hasher(identity) T::AccountId => T::AccountId;370 pub ContractSelfSponsoring get(fn contract_self_sponsoring): map hasher(identity) T::AccountId => bool;371 }372 add_extra_genesis {373 build(|config: &GenesisConfig<T>| {374 375 for (_num, _c) in &config.collection {376 <Module<T>>::init_collection(_c);377 }378379 for (_num, _q, _i) in &config.nft_item_id {380 <Module<T>>::init_nft_token(_i);381 }382383 for (_num, _q, _i) in &config.fungible_item_id {384 <Module<T>>::init_fungible_token(_i);385 }386387 for (_num, _q, _i) in &config.refungible_item_id {388 <Module<T>>::init_refungible_token(_i);389 }390 })391 }392}393394decl_event!(395 pub enum Event<T>396 where397 AccountId = <T as system::Trait>::AccountId,398 {399 400 401 402 403 404 405 406 407 408 Created(u64, u8, AccountId),409410 411 412 413 414 415 416 417 ItemCreated(u64, u64),418419 420 421 422 423 424 425 426 ItemDestroyed(u64, u64),427 }428);429430decl_module! {431 pub struct Module<T: Trait> for enum Call where origin: T::Origin {432433 fn deposit_event() = default;434 type Error = Error<T>;435436 fn on_initialize(now: T::BlockNumber) -> Weight {437438 if ChainVersion::get() < 2439 {440 let value = NextCollectionID::get();441 CreatedCollectionCount::put(value);442 ChainVersion::put(2);443 }444445 0446 }447448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 #[weight = T::WeightInfo::create_collection()]465 pub fn create_collection(origin,466 collection_name: Vec<u16>,467 collection_description: Vec<u16>,468 token_prefix: Vec<u8>,469 mode: CollectionMode) -> DispatchResult {470471 472 let who = ensure_signed(origin)?;473474 let decimal_points = match mode {475 CollectionMode::Fungible(points) => points,476 CollectionMode::ReFungible(points) => points,477 _ => 0478 };479480 481 ensure!(CollectionCount::get() < ChainLimit::get().collection_numbers_limit, Error::<T>::TotalCollectionsLimitExceeded);482483 484 ensure!(decimal_points <= 4, Error::<T>::CollectionDecimalPointLimitExceeded);485486 let mut name = collection_name.to_vec();487 name.push(0);488 ensure!(name.len() <= 64, Error::<T>::CollectionNameLimitExceeded);489490 let mut description = collection_description.to_vec();491 description.push(0);492 ensure!(name.len() <= 256, Error::<T>::CollectionDescriptionLimitExceeded);493494 let mut prefix = token_prefix.to_vec();495 prefix.push(0);496 ensure!(prefix.len() <= 16, Error::<T>::CollectionTokenPrefixLimitExceeded);497498 499 let next_id = CreatedCollectionCount::get()500 .checked_add(1)501 .ok_or(Error::<T>::NumOverflow)?;502503 504 let total = CollectionCount::get()505 .checked_add(1)506 .ok_or(Error::<T>::NumOverflow)?;507508 CreatedCollectionCount::put(next_id);509 CollectionCount::put(total);510511 512 let new_collection = CollectionType {513 owner: who.clone(),514 name: name,515 mode: mode.clone(),516 mint_mode: false,517 access: AccessMode::Normal,518 description: description,519 decimal_points: decimal_points,520 token_prefix: prefix,521 offchain_schema: Vec::new(),522 sponsor: T::AccountId::default(),523 unconfirmed_sponsor: T::AccountId::default(),524 variable_on_chain_schema: Vec::new(),525 const_on_chain_schema: Vec::new(),526 };527528 529 <Collection<T>>::insert(next_id, new_collection);530531 532 Self::deposit_event(RawEvent::Created(next_id, mode.into(), who.clone()));533534 Ok(())535 }536537 538 539 540 541 542 543 544 545 546 #[weight = T::WeightInfo::destroy_collection()]547 pub fn destroy_collection(origin, collection_id: u64) -> DispatchResult {548549 let sender = ensure_signed(origin)?;550 Self::check_owner_permissions(collection_id, sender)?;551552 <AddressTokens<T>>::remove_prefix(collection_id);553 <ApprovedList<T>>::remove_prefix(collection_id);554 <Balance<T>>::remove_prefix(collection_id);555 <ItemListIndex>::remove(collection_id);556 <AdminList<T>>::remove(collection_id);557 <Collection<T>>::remove(collection_id);558 <WhiteList<T>>::remove(collection_id);559560 <NftItemList<T>>::remove_prefix(collection_id);561 <FungibleItemList<T>>::remove_prefix(collection_id);562 <ReFungibleItemList<T>>::remove_prefix(collection_id);563564 <NftTransferBasket<T>>::remove_prefix(collection_id);565 <FungibleTransferBasket<T>>::remove_prefix(collection_id);566 <ReFungibleTransferBasket<T>>::remove_prefix(collection_id);567568 if CollectionCount::get() > 0569 {570 571 let total = CollectionCount::get()572 .checked_sub(1)573 .ok_or(Error::<T>::NumOverflow)?;574575 CollectionCount::put(total);576 }577578 Ok(())579 }580581 582 583 584 585 586 587 588 589 590 591 592 593 #[weight = T::WeightInfo::add_to_white_list()]594 pub fn add_to_white_list(origin, collection_id: u64, address: T::AccountId) -> DispatchResult{595596 let sender = ensure_signed(origin)?;597 Self::check_owner_or_admin_permissions(collection_id, sender)?;598599 let mut white_list_collection: Vec<T::AccountId>;600 if <WhiteList<T>>::contains_key(collection_id) {601 white_list_collection = <WhiteList<T>>::get(collection_id);602 if !white_list_collection.contains(&address.clone())603 {604 white_list_collection.push(address.clone());605 }606 }607 else {608 white_list_collection = Vec::new();609 white_list_collection.push(address.clone());610 }611612 <WhiteList<T>>::insert(collection_id, white_list_collection);613 Ok(())614 }615616 617 618 619 620 621 622 623 624 625 626 627 628 #[weight = T::WeightInfo::remove_from_white_list()]629 pub fn remove_from_white_list(origin, collection_id: u64, address: T::AccountId) -> DispatchResult{630631 let sender = ensure_signed(origin)?;632 Self::check_owner_or_admin_permissions(collection_id, sender)?;633634 if <WhiteList<T>>::contains_key(collection_id) {635 let mut white_list_collection = <WhiteList<T>>::get(collection_id);636 if white_list_collection.contains(&address.clone())637 {638 white_list_collection.retain(|i| *i != address.clone());639 <WhiteList<T>>::insert(collection_id, white_list_collection);640 }641 }642643 Ok(())644 }645646 647 648 649 650 651 652 653 654 655 656 657 #[weight = T::WeightInfo::set_public_access_mode()]658 pub fn set_public_access_mode(origin, collection_id: u64, mode: AccessMode) -> DispatchResult659 {660 let sender = ensure_signed(origin)?;661662 Self::check_owner_permissions(collection_id, sender)?;663 let mut target_collection = <Collection<T>>::get(collection_id);664 target_collection.access = mode;665 <Collection<T>>::insert(collection_id, target_collection);666667 Ok(())668 }669670 671 672 673 674 675 676 677 678 679 680 681 682 683 #[weight = T::WeightInfo::set_mint_permission()]684 pub fn set_mint_permission(origin, collection_id: u64, mint_permission: bool) -> DispatchResult685 {686 let sender = ensure_signed(origin)?;687688 Self::check_owner_permissions(collection_id, sender)?;689 let mut target_collection = <Collection<T>>::get(collection_id);690 target_collection.mint_mode = mint_permission;691 <Collection<T>>::insert(collection_id, target_collection);692693 Ok(())694 }695696 697 698 699 700 701 702 703 704 705 706 707 #[weight = T::WeightInfo::change_collection_owner()]708 pub fn change_collection_owner(origin, collection_id: u64, new_owner: T::AccountId) -> DispatchResult {709710 let sender = ensure_signed(origin)?;711 Self::check_owner_permissions(collection_id, sender)?;712 let mut target_collection = <Collection<T>>::get(collection_id);713 target_collection.owner = new_owner;714 <Collection<T>>::insert(collection_id, target_collection);715716 Ok(())717 }718719 720 721 722 723 724 725 726 727 728 729 730 731 732 #[weight = T::WeightInfo::add_collection_admin()]733 pub fn add_collection_admin(origin, collection_id: u64, new_admin_id: T::AccountId) -> DispatchResult {734735 let sender = ensure_signed(origin)?;736 Self::check_owner_or_admin_permissions(collection_id, sender)?;737 let mut admin_arr: Vec<T::AccountId> = Vec::new();738739 if <AdminList<T>>::contains_key(collection_id)740 {741 admin_arr = <AdminList<T>>::get(collection_id);742 ensure!(!admin_arr.contains(&new_admin_id), Error::<T>::AlreadyAdmin);743 }744745 746 ensure!((admin_arr.len() as u64) < ChainLimit::get().collections_admins_limit, Error::<T>::CollectionAdminsLimitExceeded);747748 admin_arr.push(new_admin_id);749 <AdminList<T>>::insert(collection_id, admin_arr);750751 Ok(())752 }753754 755 756 757 758 759 760 761 762 763 764 765 766 #[weight = T::WeightInfo::remove_collection_admin()]767 pub fn remove_collection_admin(origin, collection_id: u64, account_id: T::AccountId) -> DispatchResult {768769 let sender = ensure_signed(origin)?;770 Self::check_owner_or_admin_permissions(collection_id, sender)?;771772 if <AdminList<T>>::contains_key(collection_id)773 {774 let mut admin_arr = <AdminList<T>>::get(collection_id);775 admin_arr.retain(|i| *i != account_id);776 <AdminList<T>>::insert(collection_id, admin_arr);777 }778779 Ok(())780 }781782 783 784 785 786 787 788 789 790 791 #[weight = T::WeightInfo::set_collection_sponsor()]792 pub fn set_collection_sponsor(origin, collection_id: u64, new_sponsor: T::AccountId) -> DispatchResult {793794 let sender = ensure_signed(origin)?;795 ensure!(<Collection<T>>::contains_key(collection_id), Error::<T>::CollectionNotFound);796797 let mut target_collection = <Collection<T>>::get(collection_id);798 ensure!(sender == target_collection.owner, Error::<T>::NoPermission);799800 target_collection.unconfirmed_sponsor = new_sponsor;801 <Collection<T>>::insert(collection_id, target_collection);802803 Ok(())804 }805806 807 808 809 810 811 812 813 #[weight = T::WeightInfo::confirm_sponsorship()]814 pub fn confirm_sponsorship(origin, collection_id: u64) -> DispatchResult {815816 let sender = ensure_signed(origin)?;817 ensure!(<Collection<T>>::contains_key(collection_id), Error::<T>::CollectionNotFound);818819 let mut target_collection = <Collection<T>>::get(collection_id);820 ensure!(sender == target_collection.unconfirmed_sponsor, Error::<T>::ConfirmUnsetSponsorFail);821822 target_collection.sponsor = target_collection.unconfirmed_sponsor;823 target_collection.unconfirmed_sponsor = T::AccountId::default();824 <Collection<T>>::insert(collection_id, target_collection);825826 Ok(())827 }828829 830 831 832 833 834 835 836 837 838 #[weight = T::WeightInfo::remove_collection_sponsor()]839 pub fn remove_collection_sponsor(origin, collection_id: u64) -> DispatchResult {840841 let sender = ensure_signed(origin)?;842 ensure!(<Collection<T>>::contains_key(collection_id), Error::<T>::CollectionNotFound);843844 let mut target_collection = <Collection<T>>::get(collection_id);845 ensure!(sender == target_collection.owner, Error::<T>::NoPermission);846847 target_collection.sponsor = T::AccountId::default();848 <Collection<T>>::insert(collection_id, target_collection);849850 Ok(())851 }852853 854 855 856 857 858 859 860 861 862 863 864 865 866 867 868 869 870 871 872 873 874 875 876877 #[weight = T::WeightInfo::create_item(data.len())]878 pub fn create_item(origin, collection_id: u64, owner: T::AccountId, data: CreateItemData) -> DispatchResult {879880 let sender = ensure_signed(origin)?;881882 Self::collection_exists(collection_id)?;883884 let target_collection = <Collection<T>>::get(collection_id);885886 Self::can_create_items_in_collection(collection_id, &target_collection, &sender, &owner)?;887 Self::validate_create_item_args(&target_collection, &data)?;888 Self::create_item_no_validation(collection_id, &target_collection, owner, data)?;889890 Ok(())891 }892893 894 895 896 897 898 899 900 901 902 903 904 905 906 907 908 909 910 911 #[weight = T::WeightInfo::create_item(items_data.into_iter()912 .map(|data| { data.len() })913 .sum())]914 pub fn create_multiple_items(origin, collection_id: u64, owner: T::AccountId, items_data: Vec<CreateItemData>) -> DispatchResult {915916 ensure!(items_data.len() > 0, Error::<T>::EmptyArgument);917 let sender = ensure_signed(origin)?;918919 Self::collection_exists(collection_id)?;920 let target_collection = <Collection<T>>::get(collection_id);921922 Self::can_create_items_in_collection(collection_id, &target_collection, &sender, &owner)?;923924 for data in &items_data {925 Self::validate_create_item_args(&target_collection, data)?;926 }927 for data in &items_data {928 Self::create_item_no_validation(collection_id, &target_collection, owner.clone(), data.clone())?;929 }930931 Ok(())932 }933934 935 936 937 938 939 940 941 942 943 944 945 946 947 #[weight = T::WeightInfo::burn_item()]948 pub fn burn_item(origin, collection_id: u64, item_id: u64) -> DispatchResult {949950 let sender = ensure_signed(origin)?;951 Self::collection_exists(collection_id)?;952953 954 let target_collection = <Collection<T>>::get(collection_id);955 ensure!(Self::is_item_owner(sender.clone(), collection_id, item_id) ||956 Self::is_owner_or_admin_permissions(collection_id, sender.clone()),957 Error::<T>::NoPermission);958959 if target_collection.access == AccessMode::WhiteList {960 Self::check_white_list(collection_id, &sender)?;961 }962963 match target_collection.mode964 {965 CollectionMode::NFT => Self::burn_nft_item(collection_id, item_id)?,966 CollectionMode::Fungible(_) => Self::burn_fungible_item(collection_id, item_id)?,967 CollectionMode::ReFungible(_) => Self::burn_refungible_item(collection_id, item_id, sender.clone())?,968 _ => ()969 };970971 972 Self::deposit_event(RawEvent::ItemDestroyed(collection_id, item_id));973974 Ok(())975 }976977 978 979 980 981 982 983 984 985 986 987 988 989 990 991 992 993 994 995 996 997 998 999 1000 #[weight = T::WeightInfo::transfer()]1001 pub fn transfer(origin, recipient: T::AccountId, collection_id: u64, item_id: u64, value: u64) -> DispatchResult {10021003 let sender = ensure_signed(origin)?;10041005 1006 let target_collection = <Collection<T>>::get(collection_id);1007 ensure!(Self::is_item_owner(sender.clone(), collection_id, item_id) ||1008 Self::is_owner_or_admin_permissions(collection_id, sender.clone()),1009 Error::<T>::NoPermission);10101011 if target_collection.access == AccessMode::WhiteList {1012 Self::check_white_list(collection_id, &sender)?;1013 Self::check_white_list(collection_id, &recipient)?;1014 }10151016 match target_collection.mode1017 {1018 CollectionMode::NFT => Self::transfer_nft(collection_id, item_id, sender.clone(), recipient)?,1019 CollectionMode::Fungible(_) => Self::transfer_fungible(collection_id, item_id, value, sender.clone(), recipient)?,1020 CollectionMode::ReFungible(_) => Self::transfer_refungible(collection_id, item_id, value, sender.clone(), recipient)?,1021 _ => ()1022 };10231024 Ok(())1025 }10261027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037 1038 1039 1040 1041 1042 #[weight = T::WeightInfo::approve()]1043 pub fn approve(origin, approved: T::AccountId, collection_id: u64, item_id: u64) -> DispatchResult {10441045 let sender = ensure_signed(origin)?;10461047 1048 let target_collection = <Collection<T>>::get(collection_id);1049 ensure!(Self::is_item_owner(sender.clone(), collection_id, item_id) ||1050 Self::is_owner_or_admin_permissions(collection_id, sender.clone()),1051 Error::<T>::NoPermission);10521053 if target_collection.access == AccessMode::WhiteList {1054 Self::check_white_list(collection_id, &sender)?;1055 Self::check_white_list(collection_id, &approved)?;1056 }10571058 1059 let amount = 100000000;10601061 let list_exists = <ApprovedList<T>>::contains_key(collection_id, (item_id, sender.clone()));1062 if list_exists {10631064 let mut list = <ApprovedList<T>>::get(collection_id, (item_id, sender.clone()));1065 let item_contains = list.iter().any(|i| i.approved == approved);10661067 if !item_contains {1068 list.push(ApprovePermissions { approved: approved.clone(), amount: amount });1069 <ApprovedList<T>>::insert(collection_id, (item_id, sender.clone()), list);1070 }1071 } else {10721073 let mut list = Vec::new();1074 list.push(ApprovePermissions { approved: approved.clone(), amount: amount });1075 <ApprovedList<T>>::insert(collection_id, (item_id, sender.clone()), list);1076 }10771078 Ok(())1079 }1080 1081 1082 1083 1084 1085 1086 1087 1088 1089 1090 1091 1092 1093 1094 1095 1096 1097 1098 1099 1100 #[weight = T::WeightInfo::transfer_from()]1101 pub fn transfer_from(origin, from: T::AccountId, recipient: T::AccountId, collection_id: u64, item_id: u64, value: u64 ) -> DispatchResult {11021103 let sender = ensure_signed(origin)?;1104 let mut appoved_transfer = false;11051106 1107 if <ApprovedList<T>>::contains_key(collection_id, (item_id, from.clone())) {1108 let list_itm = <ApprovedList<T>>::get(collection_id, (item_id, from.clone()));1109 let opt_item = list_itm.iter().find(|i| i.approved == sender.clone());1110 if opt_item.is_some()1111 {1112 appoved_transfer = true;1113 ensure!(opt_item.unwrap().amount >= value, Error::<T>::TokenValueNotEnough);1114 }1115 }11161117 1118 let target_collection = <Collection<T>>::get(collection_id);1119 ensure!(appoved_transfer || Self::is_owner_or_admin_permissions(collection_id, sender.clone()),1120 Error::<T>::NoPermission);11211122 if target_collection.access == AccessMode::WhiteList {1123 Self::check_white_list(collection_id, &sender)?;1124 Self::check_white_list(collection_id, &recipient)?;1125 }11261127 1128 let approve_list: Vec<ApprovePermissions<T::AccountId>> = <ApprovedList<T>>::get(collection_id, (item_id, from.clone()))1129 .into_iter().filter(|i| i.approved != sender.clone()).collect();1130 <ApprovedList<T>>::insert(collection_id, (item_id, from.clone()), approve_list);113111321133 match target_collection.mode1134 {1135 CollectionMode::NFT => Self::transfer_nft(collection_id, item_id, from, recipient)?,1136 CollectionMode::Fungible(_) => Self::transfer_fungible(collection_id, item_id, value, from.clone(), recipient)?,1137 CollectionMode::ReFungible(_) => Self::transfer_refungible(collection_id, item_id, value, from.clone(), recipient)?,1138 _ => ()1139 };11401141 Ok(())1142 }11431144 1145 #[weight = 0]1146 pub fn safe_transfer_from(origin, collection_id: u64, item_id: u64, new_owner: T::AccountId) -> DispatchResult {11471148 1149 1150 1151 11521153 11541155 11561157 Ok(())1158 }11591160 1161 1162 1163 1164 1165 1166 1167 1168 1169 1170 1171 1172 #[weight = T::WeightInfo::set_variable_meta_data()]1173 pub fn set_variable_meta_data (1174 origin,1175 collection_id: u64,1176 item_id: u64,1177 data: Vec<u8>1178 ) -> DispatchResult {1179 let sender = ensure_signed(origin)?;1180 1181 Self::collection_exists(collection_id)?;11821183 1184 let target_collection = <Collection<T>>::get(collection_id);1185 ensure!(Self::is_item_owner(sender.clone(), collection_id, item_id) ||1186 Self::is_owner_or_admin_permissions(collection_id, sender.clone()),1187 Error::<T>::NoPermission);11881189 Self::item_exists(collection_id, item_id, &target_collection.mode)?;11901191 match target_collection.mode1192 {1193 CollectionMode::NFT => Self::set_nft_variable_data(collection_id, item_id, data)?,1194 CollectionMode::ReFungible(_) => Self::set_re_fungible_variable_data(collection_id, item_id, data)?,1195 _ => ()1196 };11971198 Ok(())1199 }1200 12011202 1203 1204 1205 1206 1207 1208 1209 1210 1211 1212 1213 1214 #[weight = T::WeightInfo::set_offchain_schema()]1215 pub fn set_offchain_schema(1216 origin,1217 collection_id: u64,1218 schema: Vec<u8>1219 ) -> DispatchResult {1220 let sender = ensure_signed(origin)?;1221 Self::check_owner_or_admin_permissions(collection_id, sender.clone())?;12221223 let mut target_collection = <Collection<T>>::get(collection_id);1224 target_collection.offchain_schema = schema;1225 <Collection<T>>::insert(collection_id, target_collection);12261227 Ok(())1228 }12291230 1231 1232 1233 1234 1235 1236 1237 1238 1239 1240 1241 1242 #[weight = T::WeightInfo::set_const_on_chain_schema()]1243 pub fn set_const_on_chain_schema (1244 origin,1245 collection_id: u64,1246 schema: Vec<u8>1247 ) -> DispatchResult {1248 let sender = ensure_signed(origin)?;1249 Self::check_owner_or_admin_permissions(collection_id, sender.clone())?;12501251 let mut target_collection = <Collection<T>>::get(collection_id);1252 target_collection.const_on_chain_schema = schema;1253 <Collection<T>>::insert(collection_id, target_collection);12541255 Ok(())1256 }12571258 1259 1260 1261 1262 1263 1264 1265 1266 1267 1268 1269 1270 #[weight = T::WeightInfo::set_const_on_chain_schema()]1271 pub fn set_variable_on_chain_schema (1272 origin,1273 collection_id: u64,1274 schema: Vec<u8>1275 ) -> DispatchResult {1276 let sender = ensure_signed(origin)?;1277 Self::check_owner_or_admin_permissions(collection_id, sender.clone())?;12781279 let mut target_collection = <Collection<T>>::get(collection_id);1280 target_collection.variable_on_chain_schema = schema;1281 <Collection<T>>::insert(collection_id, target_collection);12821283 Ok(())1284 }12851286 1287 #[weight = 0]1288 pub fn set_chain_limits(1289 origin,1290 limits: ChainLimits1291 ) -> DispatchResult {1292 ensure_root(origin)?;1293 <ChainLimit>::put(limits);1294 Ok(())1295 }12961297 1298 1299 1300 1301 1302 1303 1304 1305 1306 1307 1308 #[weight = 0]1309 pub fn enable_contract_sponsoring(1310 origin,1311 contract_address: T::AccountId,1312 enable: bool1313 ) -> DispatchResult {1314 let sender = ensure_signed(origin)?;1315 let mut is_owner = false;1316 if <ContractOwner<T>>::contains_key(contract_address.clone()) {1317 let owner = <ContractOwner<T>>::get(&contract_address);1318 is_owner = sender == owner;1319 }1320 ensure!(is_owner, Error::<T>::NoPermission);13211322 <ContractSelfSponsoring<T>>::insert(contract_address, enable);1323 Ok(())1324 }13251326 }1327}13281329impl<T: Trait> Module<T> {13301331 fn can_create_items_in_collection(collection_id: u64, collection: &CollectionType<T::AccountId>, sender: &T::AccountId, owner: &T::AccountId) -> DispatchResult {13321333 if !Self::is_owner_or_admin_permissions(collection_id, sender.clone()) {1334 ensure!(collection.mint_mode == true, Error::<T>::PublicMintingNotAllowed);1335 Self::check_white_list(collection_id, owner)?;1336 Self::check_white_list(collection_id, sender)?;1337 }13381339 Ok(())1340 }13411342 fn validate_create_item_args(target_collection: &CollectionType<T::AccountId>, data: &CreateItemData) -> DispatchResult {1343 match target_collection.mode1344 {1345 CollectionMode::NFT => {1346 if let CreateItemData::NFT(data) = data {1347 1348 ensure!(ChainLimit::get().custom_data_limit >= data.const_data.len() as u32, "const_data exceeded data limit.");1349 ensure!(ChainLimit::get().custom_data_limit >= data.variable_data.len() as u32, "variable_data exceeded data limit.");1350 } else {1351 fail!("Not NFT item data used to mint in NFT collection.");1352 }1353 },1354 CollectionMode::Fungible(_) => {1355 if let CreateItemData::Fungible(_) = data {1356 } else {1357 fail!("Not Fungible item data used to mint in Fungible collection.");1358 }1359 },1360 CollectionMode::ReFungible(_) => {1361 if let CreateItemData::ReFungible(data) = data {13621363 1364 ensure!(ChainLimit::get().custom_data_limit >= data.const_data.len() as u32, "const_data exceeded data limit.");1365 ensure!(ChainLimit::get().custom_data_limit >= data.variable_data.len() as u32, "variable_data exceeded data limit.");1366 } else {1367 fail!("Not Re Fungible item data used to mint in Re Fungible collection.");1368 }1369 },1370 _ => { fail!("Unexpected collection type."); }1371 };13721373 Ok(())1374 }13751376 fn create_item_no_validation(collection_id: u64, collection: &CollectionType<T::AccountId>, owner: T::AccountId, data: CreateItemData) -> DispatchResult {1377 match data1378 {1379 CreateItemData::NFT(data) => {1380 let item = NftItemType {1381 collection: collection_id,1382 owner,1383 const_data: data.const_data,1384 variable_data: data.variable_data1385 };13861387 Self::add_nft_item(item)?;1388 },1389 CreateItemData::Fungible(_) => {1390 let item = FungibleItemType {1391 collection: collection_id,1392 owner,1393 value: (10 as u128).pow(collection.decimal_points)1394 };13951396 Self::add_fungible_item(item)?;1397 },1398 CreateItemData::ReFungible(data) => {1399 let mut owner_list = Vec::new();1400 let value = (10 as u128).pow(collection.decimal_points);1401 owner_list.push(Ownership {owner: owner.clone(), fraction: value});14021403 let item = ReFungibleItemType {1404 collection: collection_id,1405 owner: owner_list,1406 const_data: data.const_data,1407 variable_data: data.variable_data1408 };14091410 Self::add_refungible_item(item)?;1411 }1412 };141314141415 1416 Self::deposit_event(RawEvent::ItemCreated(collection_id, <ItemListIndex>::get(collection_id)));14171418 Ok(())1419 }14201421 fn add_fungible_item(item: FungibleItemType<T::AccountId>) -> DispatchResult {1422 let current_index = <ItemListIndex>::get(item.collection)1423 .checked_add(1)1424 .ok_or(Error::<T>::NumOverflow)?;1425 let itemcopy = item.clone();1426 let owner = item.owner.clone();1427 let value = item.value as u64;14281429 Self::add_token_index(item.collection, current_index, owner.clone())?;14301431 <ItemListIndex>::insert(item.collection, current_index);1432 <FungibleItemList<T>>::insert(item.collection, current_index, itemcopy);14331434 1435 let v: Vec<BasketItem<T::AccountId, T::BlockNumber>> = Vec::new();1436 <FungibleTransferBasket<T>>::insert(item.collection, current_index, v);1437 1438 1439 let new_balance = <Balance<T>>::get(item.collection, owner.clone())1440 .checked_add(value)1441 .ok_or(Error::<T>::NumOverflow)?;1442 <Balance<T>>::insert(item.collection, owner.clone(), new_balance);14431444 Ok(())1445 }14461447 fn add_refungible_item(item: ReFungibleItemType<T::AccountId>) -> DispatchResult {1448 let current_index = <ItemListIndex>::get(item.collection)1449 .checked_add(1)1450 .ok_or(Error::<T>::NumOverflow)?;1451 let itemcopy = item.clone();14521453 let value = item.owner.first().unwrap().fraction as u64;1454 let owner = item.owner.first().unwrap().owner.clone();14551456 Self::add_token_index(item.collection, current_index, owner.clone())?;14571458 <ItemListIndex>::insert(item.collection, current_index);1459 <ReFungibleItemList<T>>::insert(item.collection, current_index, itemcopy);14601461 1462 let block_number: T::BlockNumber = 0.into();1463 <ReFungibleTransferBasket<T>>::insert(item.collection, current_index, block_number);14641465 1466 let new_balance = <Balance<T>>::get(item.collection, owner.clone())1467 .checked_add(value)1468 .ok_or(Error::<T>::NumOverflow)?;1469 <Balance<T>>::insert(item.collection, owner.clone(), new_balance);14701471 Ok(())1472 }14731474 fn add_nft_item(item: NftItemType<T::AccountId>) -> DispatchResult {1475 let current_index = <ItemListIndex>::get(item.collection)1476 .checked_add(1)1477 .ok_or(Error::<T>::NumOverflow)?;14781479 let item_owner = item.owner.clone();1480 let collection_id = item.collection.clone();1481 Self::add_token_index(collection_id, current_index, item.owner.clone())?;14821483 <ItemListIndex>::insert(collection_id, current_index);1484 <NftItemList<T>>::insert(collection_id, current_index, item);14851486 1487 let block_number: T::BlockNumber = 0.into();1488 <NftTransferBasket<T>>::insert(collection_id, current_index, block_number);14891490 1491 let new_balance = <Balance<T>>::get(collection_id, item_owner.clone())1492 .checked_add(1)1493 .ok_or(Error::<T>::NumOverflow)?;1494 <Balance<T>>::insert(collection_id, item_owner.clone(), new_balance);14951496 Ok(())1497 }14981499 fn burn_refungible_item(1500 collection_id: u64,1501 item_id: u64,1502 owner: T::AccountId,1503 ) -> DispatchResult {1504 ensure!(1505 <ReFungibleItemList<T>>::contains_key(collection_id, item_id),1506 Error::<T>::TokenNotFound1507 );1508 let collection = <ReFungibleItemList<T>>::get(collection_id, item_id);1509 let item = collection1510 .owner1511 .iter()1512 .filter(|&i| i.owner == owner)1513 .next()1514 .unwrap();1515 Self::remove_token_index(collection_id, item_id, owner.clone())?;15161517 1518 <ApprovedList<T>>::remove(collection_id, (item_id, owner.clone()));15191520 1521 let new_balance = <Balance<T>>::get(collection_id, item.owner.clone())1522 .checked_sub(item.fraction as u64)1523 .ok_or(Error::<T>::NumOverflow)?;1524 <Balance<T>>::insert(collection_id, item.owner.clone(), new_balance);15251526 <ReFungibleItemList<T>>::remove(collection_id, item_id);15271528 Ok(())1529 }15301531 fn burn_nft_item(collection_id: u64, item_id: u64) -> DispatchResult {1532 ensure!(1533 <NftItemList<T>>::contains_key(collection_id, item_id),1534 Error::<T>::TokenNotFound1535 );1536 let item = <NftItemList<T>>::get(collection_id, item_id);1537 Self::remove_token_index(collection_id, item_id, item.owner.clone())?;15381539 1540 <ApprovedList<T>>::remove(collection_id, (item_id, item.owner.clone()));15411542 1543 let new_balance = <Balance<T>>::get(collection_id, item.owner.clone())1544 .checked_sub(1)1545 .ok_or(Error::<T>::NumOverflow)?;1546 <Balance<T>>::insert(collection_id, item.owner.clone(), new_balance);1547 <NftItemList<T>>::remove(collection_id, item_id);15481549 Ok(())1550 }15511552 fn burn_fungible_item(collection_id: u64, item_id: u64) -> DispatchResult {1553 ensure!(1554 <FungibleItemList<T>>::contains_key(collection_id, item_id),1555 Error::<T>::TokenNotFound1556 );1557 let item = <FungibleItemList<T>>::get(collection_id, item_id);1558 Self::remove_token_index(collection_id, item_id, item.owner.clone())?;15591560 1561 <ApprovedList<T>>::remove(collection_id, (item_id, item.owner.clone()));15621563 1564 let new_balance = <Balance<T>>::get(collection_id, item.owner.clone())1565 .checked_sub(item.value as u64)1566 .ok_or(Error::<T>::NumOverflow)?;1567 <Balance<T>>::insert(collection_id, item.owner.clone(), new_balance);15681569 <FungibleItemList<T>>::remove(collection_id, item_id);15701571 Ok(())1572 }15731574 fn collection_exists(collection_id: u64) -> DispatchResult {1575 ensure!(1576 <Collection<T>>::contains_key(collection_id),1577 Error::<T>::CollectionNotFound1578 );1579 Ok(())1580 }15811582 fn check_owner_permissions(collection_id: u64, subject: T::AccountId) -> DispatchResult {1583 Self::collection_exists(collection_id)?;15841585 let target_collection = <Collection<T>>::get(collection_id);1586 ensure!(1587 subject == target_collection.owner,1588 Error::<T>::NoPermission1589 );15901591 Ok(())1592 }15931594 fn is_owner_or_admin_permissions(collection_id: u64, subject: T::AccountId) -> bool {1595 let target_collection = <Collection<T>>::get(collection_id);1596 let mut result: bool = subject == target_collection.owner;1597 let exists = <AdminList<T>>::contains_key(collection_id);15981599 if !result & exists {1600 if <AdminList<T>>::get(collection_id).contains(&subject) {1601 result = true1602 }1603 }16041605 result1606 }16071608 fn check_owner_or_admin_permissions(1609 collection_id: u64,1610 subject: T::AccountId,1611 ) -> DispatchResult {1612 Self::collection_exists(collection_id)?;1613 let result = Self::is_owner_or_admin_permissions(collection_id, subject.clone());16141615 ensure!(1616 result,1617 Error::<T>::NoPermission1618 );1619 Ok(())1620 }16211622 fn is_item_owner(subject: T::AccountId, collection_id: u64, item_id: u64) -> bool {1623 let target_collection = <Collection<T>>::get(collection_id);16241625 match target_collection.mode {1626 CollectionMode::NFT => {1627 <NftItemList<T>>::get(collection_id, item_id).owner == subject1628 }1629 CollectionMode::Fungible(_) => {1630 <FungibleItemList<T>>::get(collection_id, item_id).owner == subject1631 }1632 CollectionMode::ReFungible(_) => {1633 <ReFungibleItemList<T>>::get(collection_id, item_id)1634 .owner1635 .iter()1636 .any(|i| i.owner == subject)1637 }1638 CollectionMode::Invalid => false,1639 }1640 }16411642 fn check_white_list(collection_id: u64, address: &T::AccountId) -> DispatchResult {1643 let mes = Error::<T>::AddresNotInWhiteList;1644 ensure!(<WhiteList<T>>::contains_key(collection_id), mes);1645 let wl = <WhiteList<T>>::get(collection_id);1646 ensure!(wl.contains(address), mes);16471648 Ok(())1649 }16501651 fn transfer_fungible(1652 collection_id: u64,1653 item_id: u64,1654 value: u64,1655 owner: T::AccountId,1656 new_owner: T::AccountId,1657 ) -> DispatchResult {1658 ensure!(1659 <FungibleItemList<T>>::contains_key(collection_id, item_id),1660 Error::<T>::TokenNotFound1661 );16621663 let full_item = <FungibleItemList<T>>::get(collection_id, item_id);1664 let amount = full_item.value;16651666 ensure!(amount >= value.into(), Error::<T>::TokenValueTooLow);16671668 1669 let balance_old_owner = <Balance<T>>::get(collection_id, owner.clone())1670 .checked_sub(value)1671 .ok_or(Error::<T>::NumOverflow)?;1672 <Balance<T>>::insert(collection_id, owner.clone(), balance_old_owner);16731674 let mut new_owner_account_id = 0;1675 let new_owner_items = <AddressTokens<T>>::get(collection_id, new_owner.clone());1676 if new_owner_items.len() > 0 {1677 new_owner_account_id = new_owner_items[0];1678 }16791680 let val64 = value.into();16811682 1683 if amount == val64 && new_owner_account_id == 0 {1684 1685 1686 let mut new_full_item = full_item.clone();1687 new_full_item.owner = new_owner.clone();1688 <FungibleItemList<T>>::insert(collection_id, item_id, new_full_item);16891690 1691 let balance_new_owner = <Balance<T>>::get(collection_id, new_owner.clone())1692 .checked_add(value)1693 .ok_or(Error::<T>::NumOverflow)?;1694 <Balance<T>>::insert(collection_id, new_owner.clone(), balance_new_owner);16951696 1697 Self::move_token_index(collection_id, item_id, owner.clone(), new_owner.clone())?;1698 } else {1699 let mut new_full_item = full_item.clone();1700 new_full_item.value -= val64;17011702 1703 if new_owner_account_id > 0 {1704 1705 let mut item = <FungibleItemList<T>>::get(collection_id, new_owner_account_id);1706 item.value += val64;17071708 1709 let balance_new_owner = <Balance<T>>::get(collection_id, new_owner.clone())1710 .checked_add(value)1711 .ok_or(Error::<T>::NumOverflow)?;1712 <Balance<T>>::insert(collection_id, new_owner.clone(), balance_new_owner);17131714 <FungibleItemList<T>>::insert(collection_id, new_owner_account_id, item);1715 } else {1716 1717 let item = FungibleItemType {1718 collection: collection_id,1719 owner: new_owner.clone(),1720 value: val64,1721 };17221723 Self::add_fungible_item(item)?;1724 }17251726 if amount == val64 {1727 Self::remove_token_index(collection_id, item_id, full_item.owner.clone())?;17281729 1730 <ApprovedList<T>>::remove(collection_id, (item_id, full_item.owner.clone()));1731 <FungibleItemList<T>>::remove(collection_id, item_id);1732 }17331734 <FungibleItemList<T>>::insert(collection_id, item_id, new_full_item);1735 }17361737 Ok(())1738 }17391740 fn transfer_refungible(1741 collection_id: u64,1742 item_id: u64,1743 value: u64,1744 owner: T::AccountId,1745 new_owner: T::AccountId,1746 ) -> DispatchResult {1747 ensure!(1748 <ReFungibleItemList<T>>::contains_key(collection_id, item_id),1749 Error::<T>::TokenNotFound1750 );17511752 let full_item = <ReFungibleItemList<T>>::get(collection_id, item_id);1753 let item = full_item1754 .owner1755 .iter()1756 .filter(|i| i.owner == owner)1757 .next()1758 .ok_or(Error::<T>::NumOverflow)?;1759 let amount = item.fraction;17601761 ensure!(amount >= value.into(), Error::<T>::TokenValueTooLow);17621763 1764 let balance_old_owner = <Balance<T>>::get(collection_id, item.owner.clone())1765 .checked_sub(value)1766 .ok_or(Error::<T>::NumOverflow)?;1767 <Balance<T>>::insert(collection_id, item.owner.clone(), balance_old_owner);17681769 let balance_new_owner = <Balance<T>>::get(collection_id, new_owner.clone())1770 .checked_add(value)1771 .ok_or(Error::<T>::NumOverflow)?;1772 <Balance<T>>::insert(collection_id, new_owner.clone(), balance_new_owner);17731774 let old_owner = item.owner.clone();1775 let new_owner_has_account = full_item.owner.iter().any(|i| i.owner == new_owner);1776 let val64 = value.into();17771778 1779 if amount == val64 && !new_owner_has_account {1780 1781 1782 let mut new_full_item = full_item.clone();1783 new_full_item1784 .owner1785 .iter_mut()1786 .find(|i| i.owner == owner)1787 .unwrap()1788 .owner = new_owner.clone();1789 <ReFungibleItemList<T>>::insert(collection_id, item_id, new_full_item);17901791 1792 Self::move_token_index(collection_id, item_id, old_owner.clone(), new_owner.clone())?;1793 } else {1794 let mut new_full_item = full_item.clone();1795 new_full_item1796 .owner1797 .iter_mut()1798 .find(|i| i.owner == owner)1799 .unwrap()1800 .fraction -= val64;18011802 1803 if new_owner_has_account {1804 1805 new_full_item1806 .owner1807 .iter_mut()1808 .find(|i| i.owner == new_owner)1809 .unwrap()1810 .fraction += val64;1811 } else {1812 1813 new_full_item.owner.push(Ownership {1814 owner: new_owner.clone(),1815 fraction: val64,1816 });1817 Self::add_token_index(collection_id, item_id, new_owner.clone())?;1818 }18191820 <ReFungibleItemList<T>>::insert(collection_id, item_id, new_full_item);1821 }18221823 Ok(())1824 }18251826 fn transfer_nft(1827 collection_id: u64,1828 item_id: u64,1829 sender: T::AccountId,1830 new_owner: T::AccountId,1831 ) -> DispatchResult {1832 ensure!(1833 <NftItemList<T>>::contains_key(collection_id, item_id),1834 Error::<T>::TokenNotFound1835 );18361837 let mut item = <NftItemList<T>>::get(collection_id, item_id);18381839 ensure!(1840 sender == item.owner,1841 Error::<T>::MustBeTokenOwner1842 );18431844 1845 let balance_old_owner = <Balance<T>>::get(collection_id, item.owner.clone())1846 .checked_sub(1)1847 .ok_or(Error::<T>::NumOverflow)?;1848 <Balance<T>>::insert(collection_id, item.owner.clone(), balance_old_owner);18491850 let balance_new_owner = <Balance<T>>::get(collection_id, new_owner.clone())1851 .checked_add(1)1852 .ok_or(Error::<T>::NumOverflow)?;1853 <Balance<T>>::insert(collection_id, new_owner.clone(), balance_new_owner);18541855 1856 let old_owner = item.owner.clone();1857 item.owner = new_owner.clone();1858 <NftItemList<T>>::insert(collection_id, item_id, item);18591860 1861 Self::move_token_index(collection_id, item_id, old_owner.clone(), new_owner.clone())?;18621863 1864 <ApprovedList<T>>::remove(collection_id, (item_id, old_owner));1865 Ok(())1866 }1867 1868 fn item_exists(1869 collection_id: u64,1870 item_id: u64,1871 mode: &CollectionMode1872 ) -> DispatchResult {1873 match mode {1874 CollectionMode::NFT => ensure!(<NftItemList<T>>::contains_key(collection_id, item_id), Error::<T>::TokenNotFound),1875 CollectionMode::ReFungible(_) => ensure!(<ReFungibleItemList<T>>::contains_key(collection_id, item_id), Error::<T>::TokenNotFound),1876 CollectionMode::Fungible(_) => ensure!(<FungibleItemList<T>>::contains_key(collection_id, item_id), Error::<T>::TokenNotFound),1877 _ => ()1878 };1879 1880 Ok(())1881 }18821883 fn set_re_fungible_variable_data(1884 collection_id: u64,1885 item_id: u64,1886 data: Vec<u8>1887 ) -> DispatchResult {1888 let mut item = <ReFungibleItemList<T>>::get(collection_id, item_id);18891890 item.variable_data = data;18911892 <ReFungibleItemList<T>>::insert(collection_id, item_id, item);18931894 Ok(())1895 }18961897 fn set_nft_variable_data(1898 collection_id: u64,1899 item_id: u64,1900 data: Vec<u8>1901 ) -> DispatchResult {1902 let mut item = <NftItemList<T>>::get(collection_id, item_id);1903 1904 item.variable_data = data;19051906 <NftItemList<T>>::insert(collection_id, item_id, item);1907 1908 Ok(())1909 }19101911 fn init_collection(item: &CollectionType<T::AccountId>) {1912 1913 assert!(1914 item.decimal_points <= 4,1915 "decimal_points parameter must be lower than 4"1916 );1917 assert!(1918 item.name.len() <= 64,1919 "Collection name can not be longer than 63 char"1920 );1921 assert!(1922 item.name.len() <= 256,1923 "Collection description can not be longer than 255 char"1924 );1925 assert!(1926 item.token_prefix.len() <= 16,1927 "Token prefix can not be longer than 15 char"1928 );19291930 1931 let next_id = CreatedCollectionCount::get()1932 .checked_add(1)1933 .unwrap();19341935 CreatedCollectionCount::put(next_id);1936 }19371938 fn init_nft_token(item: &NftItemType<T::AccountId>) {1939 let current_index = <ItemListIndex>::get(item.collection)1940 .checked_add(1)1941 .unwrap();19421943 let item_owner = item.owner.clone();1944 let collection_id = item.collection.clone();1945 Self::add_token_index(collection_id, current_index, item.owner.clone()).unwrap();19461947 <ItemListIndex>::insert(collection_id, current_index);19481949 1950 let new_balance = <Balance<T>>::get(collection_id, item_owner.clone())1951 .checked_add(1)1952 .unwrap();1953 <Balance<T>>::insert(collection_id, item_owner.clone(), new_balance);1954 }19551956 fn init_fungible_token(item: &FungibleItemType<T::AccountId>) {1957 let current_index = <ItemListIndex>::get(item.collection)1958 .checked_add(1)1959 .unwrap();1960 let owner = item.owner.clone();1961 let value = item.value as u64;19621963 Self::add_token_index(item.collection, current_index, owner.clone()).unwrap();19641965 <ItemListIndex>::insert(item.collection, current_index);19661967 1968 let new_balance = <Balance<T>>::get(item.collection, owner.clone())1969 .checked_add(value)1970 .unwrap();1971 <Balance<T>>::insert(item.collection, owner.clone(), new_balance);1972 }19731974 fn init_refungible_token(item: &ReFungibleItemType<T::AccountId>) {1975 let current_index = <ItemListIndex>::get(item.collection)1976 .checked_add(1)1977 .unwrap();19781979 let value = item.owner.first().unwrap().fraction as u64;1980 let owner = item.owner.first().unwrap().owner.clone();19811982 Self::add_token_index(item.collection, current_index, owner.clone()).unwrap();19831984 <ItemListIndex>::insert(item.collection, current_index);19851986 1987 let new_balance = <Balance<T>>::get(item.collection, owner.clone())1988 .checked_add(value)1989 .unwrap();1990 <Balance<T>>::insert(item.collection, owner.clone(), new_balance);1991 }19921993 fn add_token_index(collection_id: u64, item_index: u64, owner: T::AccountId) -> DispatchResult {19941995 1996 if <AccountItemCount<T>>::contains_key(owner.clone()) {19971998 1999 let count = <AccountItemCount<T>>::get(owner.clone());2000 ensure!(count < ChainLimit::get().account_token_ownership_limit, Error::<T>::AddressOwnershipLimitExceeded);20012002 <AccountItemCount<T>>::insert(owner.clone(), count2003 .checked_add(1)2004 .ok_or(Error::<T>::NumOverflow)?);2005 }2006 else {2007 <AccountItemCount<T>>::insert(owner.clone(), 1);2008 }20092010 let list_exists = <AddressTokens<T>>::contains_key(collection_id, owner.clone());2011 if list_exists {2012 let mut list = <AddressTokens<T>>::get(collection_id, owner.clone());2013 let item_contains = list.contains(&item_index.clone());20142015 if !item_contains {2016 list.push(item_index.clone());2017 }20182019 <AddressTokens<T>>::insert(collection_id, owner.clone(), list);2020 } else {2021 let mut itm = Vec::new();2022 itm.push(item_index.clone());2023 <AddressTokens<T>>::insert(collection_id, owner, itm);2024 2025 }20262027 Ok(())2028 }20292030 fn remove_token_index(2031 collection_id: u64,2032 item_index: u64,2033 owner: T::AccountId,2034 ) -> DispatchResult {20352036 2037 <AccountItemCount<T>>::insert(owner.clone(), 2038 <AccountItemCount<T>>::get(owner.clone())2039 .checked_sub(1)2040 .ok_or(Error::<T>::NumOverflow)?);204120422043 let list_exists = <AddressTokens<T>>::contains_key(collection_id, owner.clone());2044 if list_exists {2045 let mut list = <AddressTokens<T>>::get(collection_id, owner.clone());2046 let item_contains = list.contains(&item_index.clone());20472048 if item_contains {2049 list.retain(|&item| item != item_index);2050 <AddressTokens<T>>::insert(collection_id, owner, list);2051 }2052 }20532054 Ok(())2055 }20562057 fn move_token_index(2058 collection_id: u64,2059 item_index: u64,2060 old_owner: T::AccountId,2061 new_owner: T::AccountId,2062 ) -> DispatchResult {2063 Self::remove_token_index(collection_id, item_index, old_owner)?;2064 Self::add_token_index(collection_id, item_index, new_owner)?;20652066 Ok(())2067 }2068}2069207020712072207320742075pub type Multiplier = FixedU128;20762077type BalanceOf<T> = <<T as transaction_payment::Trait>::Currency as Currency<2078 <T as system::Trait>::AccountId,2079>>::Balance;2080type NegativeImbalanceOf<T> = <<T as transaction_payment::Trait>::Currency as Currency<2081 <T as system::Trait>::AccountId,2082>>::NegativeImbalance;2083208420852086#[derive(Encode, Decode, Clone, Eq, PartialEq)]2087pub struct ChargeTransactionPayment<T: Trait + Send + Sync>(2088 #[codec(compact)] BalanceOf<T>2089);20902091impl<T: Trait + Send + Sync> sp_std::fmt::Debug2092 for ChargeTransactionPayment<T>2093{2094 #[cfg(feature = "std")]2095 fn fmt(&self, f: &mut sp_std::fmt::Formatter) -> sp_std::fmt::Result {2096 write!(f, "ChargeTransactionPayment<{:?}>", self.0)2097 }2098 #[cfg(not(feature = "std"))]2099 fn fmt(&self, _: &mut sp_std::fmt::Formatter) -> sp_std::fmt::Result {2100 Ok(())2101 }2102}21032104impl<T: Trait + Send + Sync> ChargeTransactionPayment<T>2105where2106 T::Call: Dispatchable<Info = DispatchInfo, PostInfo = PostDispatchInfo> + IsSubType<Call<T>> + IsSubType<pallet_contracts::Call<T>>,2107 BalanceOf<T>: Send + Sync + FixedPointOperand,2108{2109 2110 pub fn from(fee: BalanceOf<T>) -> Self {2111 Self(fee)2112 }21132114 pub fn traditional_fee(2115 len: usize,2116 info: &DispatchInfoOf<T::Call>,2117 tip: BalanceOf<T>,2118 ) -> BalanceOf<T>2119 where2120 T::Call: Dispatchable<Info = DispatchInfo>,2121 {2122 <transaction_payment::Module<T>>::compute_fee(len as u32, info, tip)2123 }21242125 fn withdraw_fee(2126 &self,2127 who: &T::AccountId,2128 call: &T::Call,2129 info: &DispatchInfoOf<T::Call>,2130 len: usize,2131 ) -> Result<(BalanceOf<T>, Option<NegativeImbalanceOf<T>>), TransactionValidityError> {2132 let tip = self.0;21332134 2135 2136 2137 2138 2139 2140 2141 let fee = Self::traditional_fee(len, info, tip);21422143 2144 2145 let mut sponsor: T::AccountId = match IsSubType::<Call<T>>::is_sub_type(call) {2146 Some(Call::create_item(collection_id, _properties, _owner)) => {2147 <Collection<T>>::get(collection_id).sponsor2148 }2149 Some(Call::transfer(_new_owner, collection_id, _item_id, _value)) => {2150 let _collection_mode = <Collection<T>>::get(collection_id).mode;21512152 2153 let sponsor_transfer = match _collection_mode {2154 CollectionMode::NFT => {2155 let basket = <NftTransferBasket<T>>::get(collection_id, _item_id);2156 let block_number = <system::Module<T>>::block_number() as T::BlockNumber;2157 let limit_time = basket + ChainLimit::get().nft_sponsor_transfer_timeout.into();2158 if block_number >= limit_time {2159 <NftTransferBasket<T>>::insert(collection_id, _item_id, block_number);2160 true2161 }2162 else {2163 false2164 }2165 }2166 CollectionMode::Fungible(_) => {2167 let mut basket = <FungibleTransferBasket<T>>::get(collection_id, _item_id);2168 let block_number = <system::Module<T>>::block_number() as T::BlockNumber;2169 if basket.iter().any(|i| i.address == _new_owner.clone())2170 {2171 let item = basket.iter_mut().find(|i| i.address == _new_owner.clone()).unwrap().clone();2172 let limit_time = item.start_block + ChainLimit::get().fungible_sponsor_transfer_timeout.into();2173 if block_number >= limit_time {2174 basket.retain(|x| x.address == item.address);2175 basket.push(BasketItem { start_block: block_number, address: _new_owner.clone() });2176 <FungibleTransferBasket<T>>::insert(collection_id, _item_id, basket);2177 true2178 }2179 else {2180 false2181 }2182 }2183 else {2184 basket.push(BasketItem { start_block: block_number, address: _new_owner.clone()});2185 true2186 }2187 }2188 CollectionMode::ReFungible(_) => {2189 let basket = <ReFungibleTransferBasket<T>>::get(collection_id, _item_id);2190 let block_number = <system::Module<T>>::block_number() as T::BlockNumber;2191 let limit_time = basket + ChainLimit::get().nft_sponsor_transfer_timeout.into();2192 if block_number >= limit_time {2193 <ReFungibleTransferBasket<T>>::insert(collection_id, _item_id, block_number);2194 true2195 } else {2196 false2197 }2198 }2199 _ => {2200 false2201 },2202 };22032204 if !sponsor_transfer {2205 T::AccountId::default()2206 } else {2207 <Collection<T>>::get(collection_id).sponsor2208 }2209 }22102211 _ => T::AccountId::default(),2212 };22132214 2215 sponsor = match IsSubType::<pallet_contracts::Call<T>>::is_sub_type(call) {22162217 2218 Some(pallet_contracts::Call::instantiate(_endowment, _gas_limit, code_hash, data)) => {22192220 let new_contract_address = <T as pallet_contracts::Trait>::DetermineContractAddress::contract_address_for(2221 code_hash,2222 &data,2223 &who,2224 );2225 <ContractOwner<T>>::insert(new_contract_address.clone(), who.clone());22262227 T::AccountId::default()2228 },22292230 2231 Some(pallet_contracts::Call::call(dest, _value, _gas_limit, _data)) => {22322233 let mut sp = T::AccountId::default();2234 let called_contract: T::AccountId = T::Lookup::lookup((*dest).clone()).unwrap_or(T::AccountId::default());2235 if <ContractSelfSponsoring<T>>::contains_key(called_contract.clone()) {2236 if <ContractSelfSponsoring<T>>::get(called_contract.clone()) {2237 sp = called_contract;2238 }2239 }22402241 sp2242 },22432244 _ => sponsor,2245 };22462247 let mut who_pays_fee: T::AccountId = sponsor.clone();2248 if sponsor == T::AccountId::default() {2249 who_pays_fee = who.clone();2250 }22512252 2253 if fee.is_zero() {2254 return Ok((fee, None));2255 }22562257 match <T as transaction_payment::Trait>::Currency::withdraw(2258 &who_pays_fee,2259 fee,2260 if tip.is_zero() {2261 WithdrawReason::TransactionPayment.into()2262 } else {2263 WithdrawReason::TransactionPayment | WithdrawReason::Tip2264 },2265 ExistenceRequirement::KeepAlive,2266 ) {2267 Ok(imbalance) => Ok((fee, Some(imbalance))),2268 Err(_) => Err(InvalidTransaction::Payment.into()),2269 }2270 }2271}227222732274impl<T: Trait + Send + Sync> SignedExtension2275 for ChargeTransactionPayment<T>2276where2277 BalanceOf<T>: Send + Sync + From<u64> + FixedPointOperand,2278 T::Call: Dispatchable<Info = DispatchInfo, PostInfo = PostDispatchInfo> + IsSubType<Call<T>> + IsSubType<pallet_contracts::Call<T>>,2279{2280 const IDENTIFIER: &'static str = "ChargeTransactionPayment";2281 type AccountId = T::AccountId;2282 type Call = T::Call;2283 type AdditionalSigned = ();2284 type Pre = (2285 BalanceOf<T>,2286 Self::AccountId,2287 Option<NegativeImbalanceOf<T>>,2288 BalanceOf<T>,2289 );2290 fn additional_signed(&self) -> sp_std::result::Result<(), TransactionValidityError> {2291 Ok(())2292 }22932294 fn validate(2295 &self,2296 _who: &Self::AccountId,2297 _call: &Self::Call,2298 _info: &DispatchInfoOf<Self::Call>,2299 _len: usize,2300 ) -> TransactionValidity {2301 Ok(ValidTransaction::default())2302 }23032304 fn pre_dispatch(2305 self,2306 who: &Self::AccountId,2307 call: &Self::Call,2308 info: &DispatchInfoOf<Self::Call>,2309 len: usize,2310 ) -> Result<Self::Pre, TransactionValidityError> {2311 let (fee, imbalance) = self.withdraw_fee(who, call, info, len)?;2312 Ok((self.0, who.clone(), imbalance, fee))2313 }23142315 fn post_dispatch(2316 pre: Self::Pre,2317 info: &DispatchInfoOf<Self::Call>,2318 post_info: &PostDispatchInfoOf<Self::Call>,2319 len: usize,2320 _result: &DispatchResult,2321 ) -> Result<(), TransactionValidityError> {2322 let (tip, who, imbalance, fee) = pre;2323 if let Some(payed) = imbalance {2324 let actual_fee = <transaction_payment::Module<T>>::compute_actual_fee(2325 len as u32, info, post_info, tip,2326 );2327 let refund = fee.saturating_sub(actual_fee);2328 let actual_payment =2329 match <T as transaction_payment::Trait>::Currency::deposit_into_existing(2330 &who, refund,2331 ) {2332 Ok(refund_imbalance) => {2333 2334 2335 match payed.offset(refund_imbalance) {2336 Ok(actual_payment) => actual_payment,2337 Err(_) => return Err(InvalidTransaction::Payment.into()),2338 }2339 }2340 2341 2342 Err(_) => payed,2343 };2344 let imbalances = actual_payment.split(tip);2345 <T as transaction_payment::Trait>::OnTransactionPayment::on_unbalanceds(2346 Some(imbalances.0).into_iter().chain(Some(imbalances.1)),2347 );2348 }2349 Ok(())2350 }2351}23522353