git.delta.rocks / unique-network / refs/commits / 2050a76c8808

--- a/pallets/common/src/dispatch.rs
+++ b/pallets/common/src/dispatch.rs
@@ -36,6 +36,13 @@
 			},
 			error,
 		})?;
+	handle.check_is_internal().map_err(|error| DispatchErrorWithPostInfo {
+		post_info: PostDispatchInfo {
+			actual_weight: Some(dispatch_weight::<T>()),
+			pays_fee: Pays::Yes,
+		},
+		error,
+	})?;
 	let dispatched = T::CollectionDispatch::dispatch(handle);
 	let mut result = call(dispatched.as_dyn());
 	match &mut result {

--- a/pallets/common/src/erc.rs
+++ b/pallets/common/src/erc.rs
@@ -316,8 +316,9 @@
 }
 
 fn save<T: Config>(collection: &CollectionHandle<T>) -> Result<void> {
+	// TODO possibly delete for the lack of transaction
 	collection
-		.check_is_mutable()
+		.check_is_internal()
 		.map_err(dispatch_to_evm::<T>)?;
 	<crate::CollectionById<T>>::insert(collection.id, collection.collection.clone());
 	Ok(())

--- a/pallets/common/src/lib.rs
+++ b/pallets/common/src/lib.rs
@@ -149,20 +149,16 @@
 			))
 	}
 	pub fn save(self) -> Result<(), DispatchError> {
-		self.check_is_mutable()?;
 		<CollectionById<T>>::insert(self.id, self.collection);
 		Ok(())
 	}
 
 	pub fn set_sponsor(&mut self, sponsor: T::AccountId) -> DispatchResult {
-		self.check_is_mutable()?;
 		self.collection.sponsorship = SponsorshipState::Unconfirmed(sponsor);
 		Ok(())
 	}
 
 	pub fn confirm_sponsorship(&mut self, sender: &T::AccountId) -> Result<bool, DispatchError> {
-		self.check_is_mutable()?;
-
 		if self.collection.sponsorship.pending_sponsor() != Some(sender) {
 			return Ok(false);
 		}
@@ -171,11 +167,21 @@
 		Ok(true)
 	}
 
-	/// Checks that collection is can be mutate.
-	/// Now check only `external_collection` flag and if it **true**, than return `CollectionIsReadOnly` error.
-	pub fn check_is_mutable(&self) -> DispatchResult {
+	/// Checks that the collection was created with, and must be operated upon through **Unique API**.
+	/// Now check only the `external_collection` flag and if it's **true**, then return `CollectionIsExternal` error.
+	pub fn check_is_internal(&self) -> DispatchResult {
 		if self.external_collection {
-			return Err(<Error<T>>::CollectionIsReadOnly)?;
+			return Err(<Error<T>>::CollectionIsExternal)?;
+		}
+
+		Ok(())
+	}
+
+	/// Checks that the collection was created with, and must be operated upon through an **assimilated API**.
+	/// Now check only the `external_collection` flag and if it's **false**, then return `CollectionIsInternal` error.
+	pub fn check_is_external(&self) -> DispatchResult {
+		if !self.external_collection {
+			return Err(<Error<T>>::CollectionIsInternal)?;
 		}
 
 		Ok(())
@@ -449,8 +455,11 @@
 		/// Empty property keys are forbidden
 		EmptyPropertyKey,
 
-		/// Collection is read only
-		CollectionIsReadOnly,
+		/// Tried to access an external collection with an internal API
+		CollectionIsExternal,
+
+		/// Tried to access an internal collection with an external API
+		CollectionIsInternal,
 	}
 
 	#[pallet::storage]
@@ -754,6 +763,7 @@
 	pub fn init_collection(
 		owner: T::CrossAccountId,
 		data: CreateCollectionData<T::AccountId>,
+		is_external: bool,
 	) -> Result<CollectionId, DispatchError> {
 		{
 			ensure!(
@@ -797,7 +807,7 @@
 					Self::clamp_permissions(data.mode.clone(), &Default::default(), permissions)
 				})
 				.unwrap_or_else(|| Ok(CollectionPermissions::default()))?,
-			external_collection: false,
+			external_collection: is_external,
 		};
 
 		let mut collection_properties = up_data_structs::CollectionProperties::get();
@@ -854,7 +864,6 @@
 		collection: CollectionHandle<T>,
 		sender: &T::CrossAccountId,
 	) -> DispatchResult {
-		collection.check_is_mutable()?;
 		ensure!(
 			collection.limits.owner_can_destroy(),
 			<Error<T>>::NoPermission,
@@ -884,7 +893,6 @@
 		sender: &T::CrossAccountId,
 		property: Property,
 	) -> DispatchResult {
-		collection.check_is_mutable()?;
 		collection.check_is_owner_or_admin(sender)?;
 
 		CollectionProperties::<T>::try_mutate(collection.id, |properties| {
@@ -930,8 +938,6 @@
 		sender: &T::CrossAccountId,
 		properties: Vec<Property>,
 	) -> DispatchResult {
-		collection.check_is_mutable()?;
-
 		for property in properties {
 			Self::set_collection_property(collection, sender, property)?;
 		}
@@ -944,7 +950,6 @@
 		sender: &T::CrossAccountId,
 		property_key: PropertyKey,
 	) -> DispatchResult {
-		collection.check_is_mutable()?;
 		collection.check_is_owner_or_admin(sender)?;
 
 		CollectionProperties::<T>::try_mutate(collection.id, |properties| {
@@ -966,8 +971,6 @@
 		sender: &T::CrossAccountId,
 		property_keys: Vec<PropertyKey>,
 	) -> DispatchResult {
-		collection.check_is_mutable()?;
-
 		for key in property_keys {
 			Self::delete_collection_property(collection, sender, key)?;
 		}
@@ -992,7 +995,6 @@
 		sender: &T::CrossAccountId,
 		property_permission: PropertyKeyPermission,
 	) -> DispatchResult {
-		collection.check_is_mutable()?;
 		collection.check_is_owner_or_admin(sender)?;
 
 		let all_permissions = CollectionPropertyPermissions::<T>::get(collection.id);
@@ -1024,8 +1026,6 @@
 		sender: &T::CrossAccountId,
 		property_permissions: Vec<PropertyKeyPermission>,
 	) -> DispatchResult {
-		collection.check_is_mutable()?;
-
 		for prop_pemission in property_permissions {
 			Self::set_property_permission(collection, sender, prop_pemission)?;
 		}
@@ -1113,7 +1113,6 @@
 		user: &T::CrossAccountId,
 		allowed: bool,
 	) -> DispatchResult {
-		collection.check_is_mutable()?;
 		collection.check_is_owner_or_admin(sender)?;
 
 		// =========
@@ -1133,7 +1132,6 @@
 		user: &T::CrossAccountId,
 		admin: bool,
 	) -> DispatchResult {
-		collection.check_is_mutable()?;
 		collection.check_is_owner_or_admin(sender)?;
 
 		let was_admin = <IsAdmin<T>>::get((collection.id, user));

--- a/pallets/fungible/src/lib.rs
+++ b/pallets/fungible/src/lib.rs
@@ -137,7 +137,7 @@
 		owner: T::CrossAccountId,
 		data: CreateCollectionData<T::AccountId>,
 	) -> Result<CollectionId, DispatchError> {
-		<PalletCommon<T>>::init_collection(owner, data)
+		<PalletCommon<T>>::init_collection(owner, data, false)
 	}
 	pub fn destroy_collection(
 		collection: FungibleHandle<T>,
@@ -168,8 +168,6 @@
 		owner: &T::CrossAccountId,
 		amount: u128,
 	) -> DispatchResult {
-		collection.check_is_mutable()?;
-
 		let total_supply = <TotalSupply<T>>::get(collection.id)
 			.checked_sub(amount)
 			.ok_or(<CommonError<T>>::TokenValueTooLow)?;
@@ -216,8 +214,6 @@
 		amount: u128,
 		nesting_budget: &dyn Budget,
 	) -> DispatchResult {
-		collection.check_is_mutable()?;
-
 		ensure!(
 			collection.limits.transfers_enabled(),
 			<CommonError<T>>::TransferNotAllowed,
@@ -287,8 +283,6 @@
 		data: BTreeMap<T::CrossAccountId, u128>,
 		nesting_budget: &dyn Budget,
 	) -> DispatchResult {
-		collection.check_is_mutable()?;
-
 		if !collection.is_owner_or_admin(sender) {
 			ensure!(
 				collection.permissions.mint_mode(),
@@ -390,7 +384,6 @@
 		spender: &T::CrossAccountId,
 		amount: u128,
 	) -> DispatchResult {
-		collection.check_is_mutable()?;
 		if collection.permissions.access() == AccessMode::AllowList {
 			collection.check_allowlist(owner)?;
 			collection.check_allowlist(spender)?;

--- a/pallets/nonfungible/src/lib.rs
+++ b/pallets/nonfungible/src/lib.rs
@@ -304,8 +304,9 @@
 	pub fn init_collection(
 		owner: T::CrossAccountId,
 		data: CreateCollectionData<T::AccountId>,
+		is_external: bool,
 	) -> Result<CollectionId, DispatchError> {
-		<PalletCommon<T>>::init_collection(owner, data)
+		<PalletCommon<T>>::init_collection(owner, data, is_external)
 	}
 	pub fn destroy_collection(
 		collection: NonfungibleHandle<T>,
@@ -336,8 +337,6 @@
 		sender: &T::CrossAccountId,
 		token: TokenId,
 	) -> DispatchResult {
-		collection.check_is_mutable()?;
-
 		let token_data =
 			<TokenData<T>>::get((collection.id, token)).ok_or(<CommonError<T>>::TokenNotFound)?;
 		ensure!(
@@ -458,7 +457,6 @@
 			&property.key,
 			is_token_create,
 		)?;
-		collection.check_is_mutable()?;
 
 		<TokenProperties<T>>::try_mutate((collection.id, token_id), |properties| {
 			let property = property.clone();
@@ -496,7 +494,6 @@
 		token_id: TokenId,
 		property_key: PropertyKey,
 	) -> DispatchResult {
-		collection.check_is_mutable()?;
 		Self::check_token_change_permission(collection, sender, token_id, &property_key, false)?;
 
 		<TokenProperties<T>>::try_mutate((collection.id, token_id), |properties| {
@@ -574,8 +571,6 @@
 		token_id: TokenId,
 		property_keys: Vec<PropertyKey>,
 	) -> DispatchResult {
-		collection.check_is_mutable()?;
-
 		for key in property_keys {
 			Self::delete_token_property(collection, sender, token_id, key)?;
 		}
@@ -622,8 +617,6 @@
 		token: TokenId,
 		nesting_budget: &dyn Budget,
 	) -> DispatchResult {
-		collection.check_is_mutable()?;
-
 		ensure!(
 			collection.limits.transfers_enabled(),
 			<CommonError<T>>::TransferNotAllowed
@@ -902,8 +895,6 @@
 		token: TokenId,
 		spender: Option<&T::CrossAccountId>,
 	) -> DispatchResult {
-		collection.check_is_mutable()?;
-
 		if collection.permissions.access() == AccessMode::AllowList {
 			collection.check_allowlist(sender)?;
 			if let Some(spender) = spender {

235				Self::unique_collection_id(collection_id)?,235				Self::unique_collection_id(collection_id)?,
236				misc::CollectionType::Regular,236				misc::CollectionType::Regular,
237			)?;237			)?;
238			collection.check_is_external()?;
238239
239			<PalletNft<T>>::destroy_collection(collection, &cross_sender)240			<PalletNft<T>>::destroy_collection(collection, &cross_sender)
240				.map_err(Self::map_unique_err_to_proxy)?;241				.map_err(Self::map_unique_err_to_proxy)?;
256		) -> DispatchResult {257		) -> DispatchResult {
257			let sender = ensure_signed(origin)?;258			let sender = ensure_signed(origin)?;
258259
260			let collection = Self::get_nft_collection(Self::unique_collection_id(collection_id)?)?;
261			collection.check_is_external()?;
262
259			let new_issuer = T::Lookup::lookup(new_issuer)?;263			let new_issuer = T::Lookup::lookup(new_issuer)?;
260264
261			Self::change_collection_owner(265			Self::change_collection_owner(
287				Self::unique_collection_id(collection_id)?,291				Self::unique_collection_id(collection_id)?,
288				misc::CollectionType::Regular,292				misc::CollectionType::Regular,
289			)?;293			)?;
294			collection.check_is_external()?;
290295
291			Self::check_collection_owner(&collection, &cross_sender)?;296			Self::check_collection_owner(&collection, &cross_sender)?;
292297
319			let sender = T::CrossAccountId::from_sub(sender);324			let sender = T::CrossAccountId::from_sub(sender);
320			let cross_owner = T::CrossAccountId::from_sub(owner.clone());325			let cross_owner = T::CrossAccountId::from_sub(owner.clone());
321326
327			let collection = Self::get_typed_nft_collection(
328				Self::unique_collection_id(collection_id)?,
329				misc::CollectionType::Regular,
330			)?;
331			collection.check_is_external()?;
332
322			let royalty_info = royalty_amount.map(|amount| rmrk_traits::RoyaltyInfo {333			let royalty_info = royalty_amount.map(|amount| rmrk_traits::RoyaltyInfo {
323				recipient: recipient.unwrap_or_else(|| owner.clone()),334				recipient: recipient.unwrap_or_else(|| owner.clone()),
324				amount,335				amount,
325			});336			});
326337
327			let collection = Self::get_typed_nft_collection(
328				Self::unique_collection_id(collection_id)?,
329				misc::CollectionType::Regular,
330			)?;
331
332			let nft_id = Self::create_nft(338			let nft_id = Self::create_nft(
333				&sender,339				&sender,
334				&cross_owner,340				&cross_owner,
382			let sender = ensure_signed(origin)?;388			let sender = ensure_signed(origin)?;
383			let cross_sender = T::CrossAccountId::from_sub(sender.clone());389			let cross_sender = T::CrossAccountId::from_sub(sender.clone());
384390
391			let collection = Self::get_typed_nft_collection(
392				Self::unique_collection_id(collection_id)?,
393				misc::CollectionType::Regular,
394			)?;
395			collection.check_is_external()?;
396
385			Self::destroy_nft(397			Self::destroy_nft(
386				cross_sender,398				cross_sender,
387				Self::unique_collection_id(collection_id)?,399				Self::unique_collection_id(collection_id)?,
411			let collection_id = Self::unique_collection_id(rmrk_collection_id)?;423			let collection_id = Self::unique_collection_id(rmrk_collection_id)?;
412			let nft_id = rmrk_nft_id.into();424			let nft_id = rmrk_nft_id.into();
413425
426			let collection =
427				Self::get_typed_nft_collection(collection_id, misc::CollectionType::Regular)?;
428			collection.check_is_external()?;
429
414			let token_data =430			let token_data =
415				<TokenData<T>>::get((collection_id, nft_id)).ok_or(<Error<T>>::NoAvailableNftId)?;431				<TokenData<T>>::get((collection_id, nft_id)).ok_or(<Error<T>>::NoAvailableNftId)?;
416432
417			let from = token_data.owner;433			let from = token_data.owner;
418434
419			let collection =
420				Self::get_typed_nft_collection(collection_id, misc::CollectionType::Regular)?;
421
422			ensure!(435			ensure!(
423				Self::get_nft_property_decoded(collection_id, nft_id, RmrkProperty::Transferable)?,436				Self::get_nft_property_decoded(collection_id, nft_id, RmrkProperty::Transferable)?,
424				<Error<T>>::NonTransferable437				<Error<T>>::NonTransferable
516529
517			let collection =530			let collection =
518				Self::get_typed_nft_collection(collection_id, misc::CollectionType::Regular)?;531				Self::get_typed_nft_collection(collection_id, misc::CollectionType::Regular)?;
532			collection.check_is_external()?;
519533
520			let new_cross_owner = match new_owner {534			let new_cross_owner = match new_owner {
521				RmrkAccountIdOrCollectionNftTuple::AccountId(ref account_id) => {535				RmrkAccountIdOrCollectionNftTuple::AccountId(ref account_id) => {
581			let collection_id = Self::unique_collection_id(rmrk_collection_id)?;595			let collection_id = Self::unique_collection_id(rmrk_collection_id)?;
582			let nft_id = rmrk_nft_id.into();596			let nft_id = rmrk_nft_id.into();
583597
598			let collection =
599				Self::get_typed_nft_collection(collection_id, misc::CollectionType::Regular)?;
600			collection.check_is_external()?;
601
584			Self::destroy_nft(cross_sender, collection_id, nft_id).map_err(|err| {602			Self::destroy_nft(cross_sender, collection_id, nft_id).map_err(|err| {
585				if err == <CommonError<T>>::NoPermission.into()603				if err == <CommonError<T>>::NoPermission.into()
586					|| err == <CommonError<T>>::ApprovedValueTooLow.into()604					|| err == <CommonError<T>>::ApprovedValueTooLow.into()
613631
614			let collection_id = Self::unique_collection_id(rmrk_collection_id)632			let collection_id = Self::unique_collection_id(rmrk_collection_id)
615				.map_err(|_| <Error<T>>::ResourceDoesntExist)?;633				.map_err(|_| <Error<T>>::ResourceDoesntExist)?;
634			let collection =
635				Self::get_typed_nft_collection(collection_id, misc::CollectionType::Regular)?;
636			collection.check_is_external()?;
616637
617			let nft_id = rmrk_nft_id.into();638			let nft_id = rmrk_nft_id.into();
618			let resource_id = rmrk_resource_id.into();639			let resource_id = rmrk_resource_id.into();
666687
667			let collection_id = Self::unique_collection_id(rmrk_collection_id)688			let collection_id = Self::unique_collection_id(rmrk_collection_id)
668				.map_err(|_| <Error<T>>::ResourceDoesntExist)?;689				.map_err(|_| <Error<T>>::ResourceDoesntExist)?;
690			let collection =
691				Self::get_typed_nft_collection(collection_id, misc::CollectionType::Regular)?;
692			collection.check_is_external()?;
669693
670			let nft_id = rmrk_nft_id.into();694			let nft_id = rmrk_nft_id.into();
671			let resource_id = rmrk_resource_id.into();695			let resource_id = rmrk_resource_id.into();
720			let sender = T::CrossAccountId::from_sub(sender);744			let sender = T::CrossAccountId::from_sub(sender);
721745
722			let collection_id = Self::unique_collection_id(rmrk_collection_id)?;746			let collection_id = Self::unique_collection_id(rmrk_collection_id)?;
747			let collection =
748				Self::get_typed_nft_collection(collection_id, misc::CollectionType::Regular)?;
749			collection.check_is_external()?;
750
723			let budget = budget::Value::new(NESTING_BUDGET);751			let budget = budget::Value::new(NESTING_BUDGET);
724752
725			match maybe_nft_id {753			match maybe_nft_id {
775803
776			let collection_id = Self::unique_collection_id(rmrk_collection_id)?;804			let collection_id = Self::unique_collection_id(rmrk_collection_id)?;
777			let nft_id = rmrk_nft_id.into();805			let nft_id = rmrk_nft_id.into();
806
807			let collection =
808				Self::get_typed_nft_collection(collection_id, misc::CollectionType::Regular)?;
809			collection.check_is_external()?;
810
778			let budget = budget::Value::new(NESTING_BUDGET);811			let budget = budget::Value::new(NESTING_BUDGET);
779812
780			Self::ensure_nft_type(collection_id, nft_id, NftType::Regular)?;813			Self::ensure_nft_type(collection_id, nft_id, NftType::Regular)?;
799		#[transactional]832		#[transactional]
800		pub fn add_basic_resource(833		pub fn add_basic_resource(
801			origin: OriginFor<T>,834			origin: OriginFor<T>,
802			collection_id: RmrkCollectionId,835			rmrk_collection_id: RmrkCollectionId,
803			nft_id: RmrkNftId,836			nft_id: RmrkNftId,
804			resource: RmrkBasicResource,837			resource: RmrkBasicResource,
805		) -> DispatchResult {838		) -> DispatchResult {
806			let sender = ensure_signed(origin.clone())?;839			let sender = ensure_signed(origin.clone())?;
807840
841			let collection_id = Self::unique_collection_id(rmrk_collection_id)?;
842			let collection =
843				Self::get_typed_nft_collection(collection_id, misc::CollectionType::Regular)?;
844			collection.check_is_external()?;
845
808			let resource_id = Self::resource_add(846			let resource_id = Self::resource_add(
809				sender,847				sender,
810				Self::unique_collection_id(collection_id)?,848				collection_id,
811				nft_id.into(),849				nft_id.into(),
812				[850				[
813					Self::rmrk_property(TokenType, &NftType::Resource)?,851					Self::rmrk_property(TokenType, &NftType::Resource)?,
831		#[transactional]869		#[transactional]
832		pub fn add_composable_resource(870		pub fn add_composable_resource(
833			origin: OriginFor<T>,871			origin: OriginFor<T>,
834			collection_id: RmrkCollectionId,872			rmrk_collection_id: RmrkCollectionId,
835			nft_id: RmrkNftId,873			nft_id: RmrkNftId,
836			_resource_id: RmrkBoundedResource,874			_resource_id: RmrkBoundedResource,
837			resource: RmrkComposableResource,875			resource: RmrkComposableResource,
838		) -> DispatchResult {876		) -> DispatchResult {
839			let sender = ensure_signed(origin.clone())?;877			let sender = ensure_signed(origin.clone())?;
840878
879			let collection_id = Self::unique_collection_id(rmrk_collection_id)?;
880			let collection =
881				Self::get_typed_nft_collection(collection_id, misc::CollectionType::Regular)?;
882			collection.check_is_external()?;
883
841			let resource_id = Self::resource_add(884			let resource_id = Self::resource_add(
842				sender,885				sender,
843				Self::unique_collection_id(collection_id)?,886				collection_id,
844				nft_id.into(),887				nft_id.into(),
845				[888				[
846					Self::rmrk_property(TokenType, &NftType::Resource)?,889					Self::rmrk_property(TokenType, &NftType::Resource)?,
866		#[transactional]909		#[transactional]
867		pub fn add_slot_resource(910		pub fn add_slot_resource(
868			origin: OriginFor<T>,911			origin: OriginFor<T>,
869			collection_id: RmrkCollectionId,912			rmrk_collection_id: RmrkCollectionId,
870			nft_id: RmrkNftId,913			nft_id: RmrkNftId,
871			resource: RmrkSlotResource,914			resource: RmrkSlotResource,
872		) -> DispatchResult {915		) -> DispatchResult {
873			let sender = ensure_signed(origin.clone())?;916			let sender = ensure_signed(origin.clone())?;
874917
918			let collection_id = Self::unique_collection_id(rmrk_collection_id)?;
919			let collection =
920				Self::get_typed_nft_collection(collection_id, misc::CollectionType::Regular)?;
921			collection.check_is_external()?;
922
875			let resource_id = Self::resource_add(923			let resource_id = Self::resource_add(
876				sender,924				sender,
877				Self::unique_collection_id(collection_id)?,925				collection_id,
878				nft_id.into(),926				nft_id.into(),
879				[927				[
880					Self::rmrk_property(TokenType, &NftType::Resource)?,928					Self::rmrk_property(TokenType, &NftType::Resource)?,
900		#[transactional]948		#[transactional]
901		pub fn remove_resource(949		pub fn remove_resource(
902			origin: OriginFor<T>,950			origin: OriginFor<T>,
903			collection_id: RmrkCollectionId,951			rmrk_collection_id: RmrkCollectionId,
904			nft_id: RmrkNftId,952			nft_id: RmrkNftId,
905			resource_id: RmrkResourceId,953			resource_id: RmrkResourceId,
906		) -> DispatchResult {954		) -> DispatchResult {
907			let sender = ensure_signed(origin.clone())?;955			let sender = ensure_signed(origin.clone())?;
908956
909			Self::resource_remove(957			let collection_id = Self::unique_collection_id(rmrk_collection_id)?;
910				sender,958			let collection =
911				Self::unique_collection_id(collection_id)?,959				Self::get_typed_nft_collection(collection_id, misc::CollectionType::Regular)?;
912				nft_id.into(),960			collection.check_is_external()?;
961
913				resource_id.into(),962			Self::resource_remove(sender, collection_id, nft_id.into(), resource_id.into())?;
914			)?;
915963
916			Self::deposit_event(Event::ResourceRemoval {964			Self::deposit_event(Event::ResourceRemoval {
917				nft_id,965				nft_id,
968		data: CreateCollectionData<T::AccountId>,1016		data: CreateCollectionData<T::AccountId>,
969		properties: impl Iterator<Item = Property>,1017		properties: impl Iterator<Item = Property>,
970	) -> Result<CollectionId, DispatchError> {1018	) -> Result<CollectionId, DispatchError> {
971		let collection_id = <PalletNft<T>>::init_collection(sender, data);1019		let collection_id = <PalletNft<T>>::init_collection(sender, data, true);
9721020
973		if let Err(DispatchError::Arithmetic(_)) = &collection_id {1021		if let Err(DispatchError::Arithmetic(_)) = &collection_id {
974			return Err(<Error<T>>::NoAvailableCollectionId.into());1022			return Err(<Error<T>>::NoAvailableCollectionId.into());

--- a/pallets/proxy-rmrk-equip/src/lib.rs
+++ b/pallets/proxy-rmrk-equip/src/lib.rs
@@ -94,7 +94,8 @@
 				..Default::default()
 			};
 
-			let collection_id_res = <PalletNft<T>>::init_collection(cross_sender.clone(), data);
+			let collection_id_res =
+				<PalletNft<T>>::init_collection(cross_sender.clone(), data, true);
 
 			if let Err(DispatchError::Arithmetic(_)) = &collection_id_res {
 				return Err(<Error<T>>::NoAvailableBaseId.into());
@@ -155,6 +156,7 @@
 				misc::CollectionType::Base,
 			)
 			.map_err(|_| <Error<T>>::BaseDoesntExist)?;
+			collection.check_is_external()?;
 
 			if theme.name.as_slice() == b"default" {
 				<BaseHasDefaultTheme<T>>::insert(collection_id, true);

--- a/pallets/refungible/src/lib.rs
+++ b/pallets/refungible/src/lib.rs
@@ -200,7 +200,7 @@
 		owner: T::CrossAccountId,
 		data: CreateCollectionData<T::AccountId>,
 	) -> Result<CollectionId, DispatchError> {
-		<PalletCommon<T>>::init_collection(owner, data)
+		<PalletCommon<T>>::init_collection(owner, data, false)
 	}
 	pub fn destroy_collection(
 		collection: RefungibleHandle<T>,
@@ -234,7 +234,6 @@
 	}
 
 	pub fn burn_token(collection: &RefungibleHandle<T>, token_id: TokenId) -> DispatchResult {
-		collection.check_is_mutable()?;
 		let burnt = <TokensBurnt<T>>::get(collection.id)
 			.checked_add(1)
 			.ok_or(ArithmeticError::Overflow)?;
@@ -254,7 +253,6 @@
 		token: TokenId,
 		amount: u128,
 	) -> DispatchResult {
-		collection.check_is_mutable()?;
 		let total_supply = <TotalSupply<T>>::get((collection.id, token))
 			.checked_sub(amount)
 			.ok_or(<CommonError<T>>::TokenValueTooLow)?;
@@ -327,7 +325,6 @@
 		amount: u128,
 		nesting_budget: &dyn Budget,
 	) -> DispatchResult {
-		collection.check_is_mutable()?;
 		ensure!(
 			collection.limits.transfers_enabled(),
 			<CommonError<T>>::TransferNotAllowed
@@ -576,7 +573,6 @@
 		token: TokenId,
 		amount: u128,
 	) -> DispatchResult {
-		collection.check_is_mutable()?;
 		if collection.permissions.access() == AccessMode::AllowList {
 			collection.check_allowlist(sender)?;
 			collection.check_allowlist(spender)?;

--- a/pallets/unique/src/eth/mod.rs
+++ b/pallets/unique/src/eth/mod.rs
@@ -92,8 +92,9 @@
 			..Default::default()
 		};
 
-		let collection_id = <pallet_nonfungible::Pallet<T>>::init_collection(caller.clone(), data)
-			.map_err(pallet_evm_coder_substrate::dispatch_to_evm::<T>)?;
+		let collection_id =
+			<pallet_nonfungible::Pallet<T>>::init_collection(caller.clone(), data, false)
+				.map_err(pallet_evm_coder_substrate::dispatch_to_evm::<T>)?;
 
 		let address = pallet_common::eth::collection_id_to_address(collection_id);
 		Ok(address)

--- a/pallets/unique/src/lib.rs
+++ b/pallets/unique/src/lib.rs
@@ -304,7 +304,7 @@
 		pub fn destroy_collection(origin, collection_id: CollectionId) -> DispatchResult {
 			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);
 			let collection = <CollectionHandle<T>>::try_get(collection_id)?;
-			collection.check_is_mutable()?;
+			collection.check_is_internal()?;
 
 			// =========
 
@@ -339,6 +339,7 @@
 
 			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);
 			let collection = <CollectionHandle<T>>::try_get(collection_id)?;
+			collection.check_is_internal()?;
 
 			<PalletCommon<T>>::toggle_allowlist(
 				&collection,
@@ -373,6 +374,7 @@
 
 			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);
 			let collection = <CollectionHandle<T>>::try_get(collection_id)?;
+			collection.check_is_internal()?;
 
 			<PalletCommon<T>>::toggle_allowlist(
 				&collection,
@@ -407,7 +409,7 @@
 			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);
 
 			let mut target_collection = <CollectionHandle<T>>::try_get(collection_id)?;
-			target_collection.check_is_mutable()?;
+			target_collection.check_is_internal()?;
 			target_collection.check_is_owner(&sender)?;
 
 			target_collection.owner = new_owner.clone();
@@ -437,6 +439,7 @@
 		pub fn add_collection_admin(origin, collection_id: CollectionId, new_admin_id: T::CrossAccountId) -> DispatchResult {
 			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);
 			let collection = <CollectionHandle<T>>::try_get(collection_id)?;
+			collection.check_is_internal()?;
 
 			<Pallet<T>>::deposit_event(Event::<T>::CollectionAdminAdded(
 				collection_id,
@@ -463,6 +466,7 @@
 		pub fn remove_collection_admin(origin, collection_id: CollectionId, account_id: T::CrossAccountId) -> DispatchResult {
 			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);
 			let collection = <CollectionHandle<T>>::try_get(collection_id)?;
+			collection.check_is_internal()?;
 
 			<Pallet<T>>::deposit_event(Event::<T>::CollectionAdminRemoved(
 				collection_id,
@@ -488,6 +492,7 @@
 
 			let mut target_collection = <CollectionHandle<T>>::try_get(collection_id)?;
 			target_collection.check_is_owner(&sender)?;
+			target_collection.check_is_internal()?;
 
 			target_collection.set_sponsor(new_sponsor.clone())?;
 
@@ -512,6 +517,7 @@
 			let sender = ensure_signed(origin)?;
 
 			let mut target_collection = <CollectionHandle<T>>::try_get(collection_id)?;
+			target_collection.check_is_internal()?;
 			ensure!(
 				target_collection.confirm_sponsorship(&sender)?,
 				Error::<T>::ConfirmUnsetSponsorFail
@@ -540,6 +546,7 @@
 			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);
 
 			let mut target_collection = <CollectionHandle<T>>::try_get(collection_id)?;
+			target_collection.check_is_internal()?;
 			target_collection.check_is_owner(&sender)?;
 
 			target_collection.sponsorship = SponsorshipState::Disabled;
@@ -704,6 +711,7 @@
 		pub fn set_transfers_enabled_flag(origin, collection_id: CollectionId, value: bool) -> DispatchResult {
 			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);
 			let mut target_collection = <CollectionHandle<T>>::try_get(collection_id)?;
+			target_collection.check_is_internal()?;
 			target_collection.check_is_owner(&sender)?;
 
 			// =========
@@ -858,6 +866,7 @@
 		) -> DispatchResult {
 			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);
 			let mut target_collection = <CollectionHandle<T>>::try_get(collection_id)?;
+			target_collection.check_is_internal()?;
 			target_collection.check_is_owner(&sender)?;
 			let old_limit = &target_collection.limits;
 
@@ -879,6 +888,7 @@
 		) -> DispatchResult {
 			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);
 			let mut target_collection = <CollectionHandle<T>>::try_get(collection_id)?;
+			target_collection.check_is_internal()?;
 			target_collection.check_is_owner(&sender)?;
 			let old_limit = &target_collection.permissions;
 

--- a/runtime/common/src/dispatch.rs
+++ b/runtime/common/src/dispatch.rs
@@ -35,7 +35,7 @@
 		data: CreateCollectionData<T::AccountId>,
 	) -> DispatchResult {
 		let _id = match data.mode {
-			CollectionMode::NFT => <PalletNonfungible<T>>::init_collection(sender, data)?,
+			CollectionMode::NFT => <PalletNonfungible<T>>::init_collection(sender, data, false)?,
 			CollectionMode::Fungible(decimal_points) => {
 				// check params
 				ensure!(