`bbe9a345e2a0`

1 file changed

modifiedpallets/nft/src/lib.rsdiff before after both
801801
802            let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);802            let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);
803            let collection = Self::get_collection(collection_id)?;803            let collection = Self::get_collection(collection_id)?;
804            Self::check_owner_permissions(&collection, sender)?;804            Self::check_owner_permissions(&collection, &sender)?;
805            if !collection.limits.owner_can_destroy {805            if !collection.limits.owner_can_destroy {
806                fail!(Error::<T>::NoPermission);806                fail!(Error::<T>::NoPermission);
807            }807            }
849849
850            let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);850            let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);
851            let collection = Self::get_collection(collection_id)?;851            let collection = Self::get_collection(collection_id)?;
852            Self::check_owner_or_admin_permissions(&collection, sender)?;852            Self::check_owner_or_admin_permissions(&collection, &sender)?;
853853
854            <WhiteList<T>>::insert(collection_id, address.as_sub(), true);854            <WhiteList<T>>::insert(collection_id, address.as_sub(), true);
855            855            
874874
875            let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);875            let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);
876            let collection = Self::get_collection(collection_id)?;876            let collection = Self::get_collection(collection_id)?;
877            Self::check_owner_or_admin_permissions(&collection, sender)?;877            Self::check_owner_or_admin_permissions(&collection, &sender)?;
878878
879            <WhiteList<T>>::remove(collection_id, address.as_sub());879            <WhiteList<T>>::remove(collection_id, address.as_sub());
880880
899            let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);899            let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);
900900
901            let mut target_collection = Self::get_collection(collection_id)?;901            let mut target_collection = Self::get_collection(collection_id)?;
902            Self::check_owner_permissions(&target_collection, sender)?;902            Self::check_owner_permissions(&target_collection, &sender)?;
903            target_collection.access = mode;903            target_collection.access = mode;
904            Self::save_collection(target_collection);904            Self::save_collection(target_collection);
905905
926            let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);926            let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);
927927
928            let mut target_collection = Self::get_collection(collection_id)?;928            let mut target_collection = Self::get_collection(collection_id)?;
929            Self::check_owner_permissions(&target_collection, sender)?;929            Self::check_owner_permissions(&target_collection, &sender)?;
930            target_collection.mint_mode = mint_permission;930            target_collection.mint_mode = mint_permission;
931            Self::save_collection(target_collection);931            Self::save_collection(target_collection);
932932
950950
951            let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);951            let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);
952            let mut target_collection = Self::get_collection(collection_id)?;952            let mut target_collection = Self::get_collection(collection_id)?;
953            Self::check_owner_permissions(&target_collection, sender)?;953            Self::check_owner_permissions(&target_collection, &sender)?;
954            target_collection.owner = new_owner;954            target_collection.owner = new_owner;
955            Self::save_collection(target_collection);955            Self::save_collection(target_collection);
956956
976
977            let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);976            let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);
978            let collection = Self::get_collection(collection_id)?;977            let collection = Self::get_collection(collection_id)?;
979            Self::check_owner_or_admin_permissions(&collection, sender)?;978            Self::check_owner_or_admin_permissions(&collection, &sender)?;
980            let mut admin_arr = <AdminList<T>>::get(collection_id);979            let mut admin_arr = <AdminList<T>>::get(collection_id);
981980
982            match admin_arr.binary_search(&new_admin_id) {981            match admin_arr.binary_search(&new_admin_id) {
1009
1010            let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1008            let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);
1011            let collection = Self::get_collection(collection_id)?;1009            let collection = Self::get_collection(collection_id)?;
1012            Self::check_owner_or_admin_permissions(&collection, sender)?;1010            Self::check_owner_or_admin_permissions(&collection, &sender)?;
1013            let mut admin_arr = <AdminList<T>>::get(collection_id);1011            let mut admin_arr = <AdminList<T>>::get(collection_id);
10141012
1015            match admin_arr.binary_search(&account_id) {1013            match admin_arr.binary_search(&account_id) {
1083            let sender = ensure_signed(origin)?;1081            let sender = ensure_signed(origin)?;
10841082
1085            let mut target_collection = Self::get_collection(collection_id)?;1083            let mut target_collection = Self::get_collection(collection_id)?;
1086            Self::check_owner_permissions(&target_collection, sender)?;1084            Self::check_owner_permissions(&target_collection, &T::CrossAccountId::from_sub(sender))?;
10871085
1088            target_collection.sponsorship = SponsorshipState::Disabled;1086            target_collection.sponsorship = SponsorshipState::Disabled;
1089            Self::save_collection(target_collection);1087            Self::save_collection(target_collection);
1361        ) -> DispatchResult {1359        ) -> DispatchResult {
1362            let sender = ensure_signed(origin)?;1360            let sender = ensure_signed(origin)?;
1363            let mut target_collection = Self::get_collection(collection_id)?;1361            let mut target_collection = Self::get_collection(collection_id)?;
1364            Self::check_owner_or_admin_permissions(&target_collection, sender.clone())?;1362            Self::check_owner_or_admin_permissions(&target_collection, &sender)?;
1365            target_collection.schema_version = version;1363            target_collection.schema_version = version;
1366            Self::save_collection(target_collection);1364            Self::save_collection(target_collection);
13671365
1389        ) -> DispatchResult {1387        ) -> DispatchResult {
1390            let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1388            let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);
1391            let mut target_collection = Self::get_collection(collection_id)?;1389            let mut target_collection = Self::get_collection(collection_id)?;
1392            Self::check_owner_or_admin_permissions(&target_collection, sender)?;1390            Self::check_owner_or_admin_permissions(&target_collection, &sender)?;
13931391
1394            // check schema limit1392            // check schema limit
1395            ensure!(schema.len() as u32 <= ChainLimit::get().offchain_schema_limit, "");1393            ensure!(schema.len() as u32 <= ChainLimit::get().offchain_schema_limit, "");
1421        ) -> DispatchResult {1419        ) -> DispatchResult {
1422            let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1420            let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);
1423            let mut target_collection = Self::get_collection(collection_id)?;1421            let mut target_collection = Self::get_collection(collection_id)?;
1424            Self::check_owner_or_admin_permissions(&target_collection, sender)?;1422            Self::check_owner_or_admin_permissions(&target_collection, &sender)?;
14251423
1426            // check schema limit1424            // check schema limit
1427            ensure!(schema.len() as u32 <= ChainLimit::get().const_on_chain_schema_limit, "");1425            ensure!(schema.len() as u32 <= ChainLimit::get().const_on_chain_schema_limit, "");
1453        ) -> DispatchResult {1451        ) -> DispatchResult {
1454            let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1452            let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);
1455            let mut target_collection = Self::get_collection(collection_id)?;1453            let mut target_collection = Self::get_collection(collection_id)?;
1456            Self::check_owner_or_admin_permissions(&target_collection, sender)?;1454            Self::check_owner_or_admin_permissions(&target_collection, &sender)?;
14571455
1458            // check schema limit1456            // check schema limit
1459            ensure!(schema.len() as u32 <= ChainLimit::get().variable_on_chain_schema_limit, "");1457            ensure!(schema.len() as u32 <= ChainLimit::get().variable_on_chain_schema_limit, "");
1640        ) -> DispatchResult {1638        ) -> DispatchResult {
1641            let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1639            let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);
1642            let mut target_collection = Self::get_collection(collection_id)?;1640            let mut target_collection = Self::get_collection(collection_id)?;
1643            Self::check_owner_permissions(&target_collection, sender.clone())?;1641            Self::check_owner_permissions(&target_collection, &sender)?;
1644            let old_limits = &target_collection.limits;1642            let old_limits = &target_collection.limits;
1645            let chain_limits = ChainLimit::get();1643            let chain_limits = ChainLimit::get();
16461644
1675        Self::is_correct_transfer(target_collection, &recipient)?;1673        Self::is_correct_transfer(target_collection, &recipient)?;
16761674
1677        // Transfer permissions check1675        // Transfer permissions check
1678        ensure!(Self::is_item_owner(sender.clone(), target_collection, item_id) ||1676        ensure!(Self::is_item_owner(&sender, target_collection, item_id) ||
1679            Self::is_owner_or_admin_permissions(target_collection, sender.clone()),1677            Self::is_owner_or_admin_permissions(target_collection, &sender),
1680            Error::<T>::NoPermission);1678            Error::<T>::NoPermission);
16811679
1682        if target_collection.access == AccessMode::WhiteList {1680        if target_collection.access == AccessMode::WhiteList {
1710		let bypasses_limits = collection.limits.owner_can_transfer &&1708		let bypasses_limits = collection.limits.owner_can_transfer &&
1711			Self::is_owner_or_admin_permissions(1709			Self::is_owner_or_admin_permissions(
1712				&collection,1710				&collection,
1713				sender.clone(),1711				&sender,
1714			);1712			);
17151713
1716		let allowance_limit = if bypasses_limits {1714		let allowance_limit = if bypasses_limits {
1717			None1715			None
1718		} else if let Some(amount) = Self::owned_amount(1716		} else if let Some(amount) = Self::owned_amount(
1719			sender.clone(),1717			&sender,
1720			&collection,1718			&collection,
1721			item_id,1719			item_id,
1722		) {1720		) {
1762			approval >= amount || 1760			approval >= amount || 
1763			(1761			(
1764				collection.limits.owner_can_transfer &&1762				collection.limits.owner_can_transfer &&
1765				Self::is_owner_or_admin_permissions(&collection, sender.clone())1763				Self::is_owner_or_admin_permissions(&collection, &sender)
1766			),1764			),
1767			Error::<T>::NoPermission1765			Error::<T>::NoPermission
1768		);1766		);
1821        value: u128,1819        value: u128,
1822    ) -> DispatchResult {1820    ) -> DispatchResult {
1823        ensure!(1821        ensure!(
1824            Self::is_item_owner(sender.clone(), &collection, item_id) ||1822            Self::is_item_owner(&sender, &collection, item_id) ||
1825            (1823            (
1826                collection.limits.owner_can_transfer &&1824                collection.limits.owner_can_transfer &&
1827                Self::is_owner_or_admin_permissions(&collection, sender.clone())1825                Self::is_owner_or_admin_permissions(&collection, &sender)
1828            ),1826            ),
1829            Error::<T>::NoPermission1827            Error::<T>::NoPermission
1830        );1828        );
1854        Ok(())1852        Ok(())
1855    }1853    }
18561854
1857    fn can_create_items_in_collection(collection: &CollectionHandle<T>, sender: &T::AccountId, owner: &T::AccountId, amount: u32) -> DispatchResult {1855    fn can_create_items_in_collection(collection: &CollectionHandle<T>, sender: &T::CrossAccountId, owner: &T::CrossAccountId, amount: u32) -> DispatchResult {
1858        let collection_id = collection.id;1856        let collection_id = collection.id;
18591857
1860        // check token limit and account token limit1858        // check token limit and account token limit
1861        let total_items: u32 = ItemListIndex::get(collection_id)1859        let total_items: u32 = ItemListIndex::get(collection_id)
1862            .checked_add(amount)1860            .checked_add(amount)
1863            .ok_or(Error::<T>::CollectionTokenLimitExceeded)?;1861            .ok_or(Error::<T>::CollectionTokenLimitExceeded)?;
1864        let account_items: u32 = (<AddressTokens<T>>::get(collection_id, owner).len() as u32)1862        let account_items: u32 = (<AddressTokens<T>>::get(collection_id, owner.as_sub()).len() as u32)
1865            .checked_add(amount)1863            .checked_add(amount)
1866            .ok_or(Error::<T>::AccountTokenLimitExceeded)?;1864            .ok_or(Error::<T>::AccountTokenLimitExceeded)?;
1867        ensure!(collection.limits.token_limit >= total_items,  Error::<T>::CollectionTokenLimitExceeded);1865        ensure!(collection.limits.token_limit >= total_items,  Error::<T>::CollectionTokenLimitExceeded);
1868        ensure!(collection.limits.account_token_ownership_limit >= account_items,  Error::<T>::AccountTokenLimitExceeded);1866        ensure!(collection.limits.account_token_ownership_limit >= account_items,  Error::<T>::AccountTokenLimitExceeded);
18691867
1870        if !Self::is_owner_or_admin_permissions(collection, sender.clone()) {1868        if !Self::is_owner_or_admin_permissions(collection, &sender) {
1871            ensure!(collection.mint_mode == true, Error::<T>::PublicMintingNotAllowed);1869            ensure!(collection.mint_mode == true, Error::<T>::PublicMintingNotAllowed);
1872            Self::check_white_list(collection, owner)?;1870            Self::check_white_list(collection, owner)?;
1873            Self::check_white_list(collection, sender)?;1871            Self::check_white_list(collection, sender)?;
2122    }2120    }
2121
21232122
2124    fn check_owner_permissions(target_collection: &CollectionHandle<T>, subject: T::AccountId) -> DispatchResult {2123    fn check_owner_permissions(target_collection: &CollectionHandle<T>, subject: &T::CrossAccountId) -> DispatchResult {
2125        ensure!(2124        ensure!(
2126            subject == target_collection.owner,2125            *subject == target_collection.owner,
2127            Error::<T>::NoPermission2126            Error::<T>::NoPermission
2128        );2127        );
21292128
2130        Ok(())2129        Ok(())
2131    }2130    }
21322131
2133    fn is_owner_or_admin_permissions(collection: &CollectionHandle<T>, subject: T::AccountId) -> bool {2132    fn is_owner_or_admin_permissions(collection: &CollectionHandle<T>, subject: &T::CrossAccountId) -> bool {
2134        subject == collection.owner || <AdminList<T>>::get(collection.id).contains(&subject)2133        *subject == collection.owner || <AdminList<T>>::get(collection.id).contains(&subject)
2135    }2134    }
21362135
2137    fn check_owner_or_admin_permissions(2136    fn check_owner_or_admin_permissions(
2138        collection: &CollectionHandle<T>,2137        collection: &CollectionHandle<T>,
2139        subject: T::AccountId,2138        subject: &T::CrossAccountId,
2140    ) -> DispatchResult {2139    ) -> DispatchResult {
2141        ensure!(Self::is_owner_or_admin_permissions(collection, subject), Error::<T>::NoPermission);2140        ensure!(Self::is_owner_or_admin_permissions(collection, subject), Error::<T>::NoPermission);
21422141
2143        Ok(())2142        Ok(())
2144    }2143    }
21452144
2146    fn owned_amount(2145    fn owned_amount(
2147        subject: T::AccountId,2146        subject: &T::CrossAccountId,
2148        target_collection: &CollectionHandle<T>,2147        target_collection: &CollectionHandle<T>,
2149        item_id: TokenId,2148        item_id: TokenId,
2150    ) -> Option<u128> {2149    ) -> Option<u128> {
2151        let collection_id = target_collection.id;2150        let collection_id = target_collection.id;
21522151
2153        match target_collection.mode {2152        match target_collection.mode {
2154            CollectionMode::NFT => (<NftItemList<T>>::get(collection_id, item_id)?.owner == subject)2153            CollectionMode::NFT => (<NftItemList<T>>::get(collection_id, item_id)?.owner == *subject)
2155                .then(|| 1),2154                .then(|| 1),
2156            CollectionMode::Fungible(_) => Some(<FungibleItemList<T>>::get(collection_id, &subject)2155            CollectionMode::Fungible(_) => Some(<FungibleItemList<T>>::get(collection_id, &subject.as_sub())
2157                .value),2156                .value),
2158            CollectionMode::ReFungible => <ReFungibleItemList<T>>::get(collection_id, item_id)?2157            CollectionMode::ReFungible => <ReFungibleItemList<T>>::get(collection_id, item_id)?
2159                .owner2158                .owner
2160                .iter()2159                .iter()
2161                .find(|i| i.owner == subject)2160                .find(|i| i.owner == *subject)
2162                .map(|i| i.fraction),2161                .map(|i| i.fraction),
2163            CollectionMode::Invalid => None,2162            CollectionMode::Invalid => None,
2164        }2163        }
2165    }2164    }
21662165
2167    fn is_item_owner(subject: T::AccountId, target_collection: &CollectionHandle<T>, item_id: TokenId) -> bool {2166    fn is_item_owner(subject: &T::CrossAccountId, target_collection: &CollectionHandle<T>, item_id: TokenId) -> bool {
2168        match target_collection.mode {2167        match target_collection.mode {
2169            CollectionMode::Fungible(_) => true,2168            CollectionMode::Fungible(_) => true,
2170            _ => Self::owned_amount(subject, target_collection, item_id).is_some(),2169            _ => Self::owned_amount(&subject, target_collection, item_id).is_some(),
2171        }2170        }
2172    }2171    }
21732172
2174    fn check_white_list(collection: &CollectionHandle<T>, address: &T::AccountId) -> DispatchResult {2173    fn check_white_list(collection: &CollectionHandle<T>, address: &T::CrossAccountId) -> DispatchResult {
2175        let collection_id = collection.id;2174        let collection_id = collection.id;
21762175
2177        let mes = Error::<T>::AddresNotInWhiteList;2176        let mes = Error::<T>::AddresNotInWhiteList;
2178        ensure!(<WhiteList<T>>::contains_key(collection_id, address), mes);2177        ensure!(<WhiteList<T>>::contains_key(collection_id, address.as_sub()), mes);
21792178
2180        Ok(())2179        Ok(())
2181    }2180    }