git.delta.rocks / unique-network / refs/commits / 17af80bda9a2

--- a/pallets/common/src/erc.rs
+++ b/pallets/common/src/erc.rs
@@ -317,7 +317,7 @@
 
 fn save<T: Config>(collection: &CollectionHandle<T>) -> Result<void> {
 	collection
-		.check_is_read_only()
+		.check_is_mutable()
 		.map_err(dispatch_to_evm::<T>)?;
 	<crate::CollectionById<T>>::insert(collection.id, collection.collection.clone());
 	Ok(())

149			))149			))
150	}150	}
151	pub fn save(self) -> Result<(), DispatchError> {151	pub fn save(self) -> Result<(), DispatchError> {
152		self.check_is_read_only()?;152		self.check_is_mutable()?;
153		<CollectionById<T>>::insert(self.id, self.collection);153		<CollectionById<T>>::insert(self.id, self.collection);
154		Ok(())154		Ok(())
155	}155	}
156156
157	pub fn set_sponsor(&mut self, sponsor: T::AccountId) -> DispatchResult {157	pub fn set_sponsor(&mut self, sponsor: T::AccountId) -> DispatchResult {
158		self.check_is_read_only()?;158		self.check_is_mutable()?;
159		self.collection.sponsorship = SponsorshipState::Unconfirmed(sponsor);159		self.collection.sponsorship = SponsorshipState::Unconfirmed(sponsor);
160		Ok(())160		Ok(())
161	}161	}
162162
163	pub fn confirm_sponsorship(&mut self, sender: &T::AccountId) -> Result<bool, DispatchError> {163	pub fn confirm_sponsorship(&mut self, sender: &T::AccountId) -> Result<bool, DispatchError> {
164		self.check_is_read_only()?;164		self.check_is_mutable()?;
165165
166		if self.collection.sponsorship.pending_sponsor() != Some(sender) {166		if self.collection.sponsorship.pending_sponsor() != Some(sender) {
167			return Ok(false);167			return Ok(false);
686			sponsorship,686			sponsorship,
687			limits,687			limits,
688			permissions,688			permissions,
689			read_only,689			external_collection,
690		} = <CollectionById<T>>::get(collection)?;690		} = <CollectionById<T>>::get(collection)?;
691691
692		let token_property_permissions = <CollectionPropertyPermissions<T>>::get(collection)692		let token_property_permissions = <CollectionPropertyPermissions<T>>::get(collection)
716			permissions,716			permissions,
717			token_property_permissions,717			token_property_permissions,
718			properties,718			properties,
719			read_only,719			read_only: external_collection,
720		})720		})
721	}721	}
722}722}
797					Self::clamp_permissions(data.mode.clone(), &Default::default(), permissions)797					Self::clamp_permissions(data.mode.clone(), &Default::default(), permissions)
798				})798				})
799				.unwrap_or_else(|| Ok(CollectionPermissions::default()))?,799				.unwrap_or_else(|| Ok(CollectionPermissions::default()))?,
800			read_only: false,800			external_collection: false,
801		};801		};
802802
803		let mut collection_properties = up_data_structs::CollectionProperties::get();803		let mut collection_properties = up_data_structs::CollectionProperties::get();
854		collection: CollectionHandle<T>,854		collection: CollectionHandle<T>,
855		sender: &T::CrossAccountId,855		sender: &T::CrossAccountId,
856	) -> DispatchResult {856	) -> DispatchResult {
857		collection.check_is_read_only()?;857		collection.check_is_mutable()?;
858		ensure!(858		ensure!(
859			collection.limits.owner_can_destroy(),859			collection.limits.owner_can_destroy(),
860			<Error<T>>::NoPermission,860			<Error<T>>::NoPermission,
884		sender: &T::CrossAccountId,884		sender: &T::CrossAccountId,
885		property: Property,885		property: Property,
886	) -> DispatchResult {886	) -> DispatchResult {
887		collection.check_is_read_only()?;887		collection.check_is_mutable()?;
888		collection.check_is_owner_or_admin(sender)?;888		collection.check_is_owner_or_admin(sender)?;
889889
890		CollectionProperties::<T>::try_mutate(collection.id, |properties| {890		CollectionProperties::<T>::try_mutate(collection.id, |properties| {
930		sender: &T::CrossAccountId,930		sender: &T::CrossAccountId,
931		properties: Vec<Property>,931		properties: Vec<Property>,
932	) -> DispatchResult {932	) -> DispatchResult {
933		collection.check_is_read_only()?;933		collection.check_is_mutable()?;
934934
935		for property in properties {935		for property in properties {
936			Self::set_collection_property(collection, sender, property)?;936			Self::set_collection_property(collection, sender, property)?;
944		sender: &T::CrossAccountId,944		sender: &T::CrossAccountId,
945		property_key: PropertyKey,945		property_key: PropertyKey,
946	) -> DispatchResult {946	) -> DispatchResult {
947		collection.check_is_read_only()?;947		collection.check_is_mutable()?;
948		collection.check_is_owner_or_admin(sender)?;948		collection.check_is_owner_or_admin(sender)?;
949949
950		CollectionProperties::<T>::try_mutate(collection.id, |properties| {950		CollectionProperties::<T>::try_mutate(collection.id, |properties| {
966		sender: &T::CrossAccountId,966		sender: &T::CrossAccountId,
967		property_keys: Vec<PropertyKey>,967		property_keys: Vec<PropertyKey>,
968	) -> DispatchResult {968	) -> DispatchResult {
969		collection.check_is_read_only()?;969		collection.check_is_mutable()?;
970970
971		for key in property_keys {971		for key in property_keys {
972			Self::delete_collection_property(collection, sender, key)?;972			Self::delete_collection_property(collection, sender, key)?;
992		sender: &T::CrossAccountId,992		sender: &T::CrossAccountId,
993		property_permission: PropertyKeyPermission,993		property_permission: PropertyKeyPermission,
994	) -> DispatchResult {994	) -> DispatchResult {
995		collection.check_is_read_only()?;995		collection.check_is_mutable()?;
996		collection.check_is_owner_or_admin(sender)?;996		collection.check_is_owner_or_admin(sender)?;
997997
998		let all_permissions = CollectionPropertyPermissions::<T>::get(collection.id);998		let all_permissions = CollectionPropertyPermissions::<T>::get(collection.id);
1024		sender: &T::CrossAccountId,1024		sender: &T::CrossAccountId,
1025		property_permissions: Vec<PropertyKeyPermission>,1025		property_permissions: Vec<PropertyKeyPermission>,
1026	) -> DispatchResult {1026	) -> DispatchResult {
1027		collection.check_is_read_only()?;1027		collection.check_is_mutable()?;
10281028
1029		for prop_pemission in property_permissions {1029		for prop_pemission in property_permissions {
1030			Self::set_property_permission(collection, sender, prop_pemission)?;1030			Self::set_property_permission(collection, sender, prop_pemission)?;
1113		user: &T::CrossAccountId,1113		user: &T::CrossAccountId,
1114		allowed: bool,1114		allowed: bool,
1115	) -> DispatchResult {1115	) -> DispatchResult {
1116		collection.check_is_read_only()?;1116		collection.check_is_mutable()?;
1117		collection.check_is_owner_or_admin(sender)?;1117		collection.check_is_owner_or_admin(sender)?;
11181118
1119		// =========1119		// =========
1133		user: &T::CrossAccountId,1133		user: &T::CrossAccountId,
1134		admin: bool,1134		admin: bool,
1135	) -> DispatchResult {1135	) -> DispatchResult {
1136		collection.check_is_read_only()?;1136		collection.check_is_mutable()?;
1137		collection.check_is_owner_or_admin(sender)?;1137		collection.check_is_owner_or_admin(sender)?;
11381138
1139		let was_admin = <IsAdmin<T>>::get((collection.id, user));1139		let was_admin = <IsAdmin<T>>::get((collection.id, user));

--- a/pallets/fungible/src/lib.rs
+++ b/pallets/fungible/src/lib.rs
@@ -168,7 +168,7 @@
 		owner: &T::CrossAccountId,
 		amount: u128,
 	) -> DispatchResult {
-		collection.check_is_read_only()?;
+		collection.check_is_mutable()?;
 
 		let total_supply = <TotalSupply<T>>::get(collection.id)
 			.checked_sub(amount)
@@ -216,7 +216,7 @@
 		amount: u128,
 		nesting_budget: &dyn Budget,
 	) -> DispatchResult {
-		collection.check_is_read_only()?;
+		collection.check_is_mutable()?;
 
 		ensure!(
 			collection.limits.transfers_enabled(),
@@ -287,7 +287,7 @@
 		data: BTreeMap<T::CrossAccountId, u128>,
 		nesting_budget: &dyn Budget,
 	) -> DispatchResult {
-		collection.check_is_read_only()?;
+		collection.check_is_mutable()?;
 
 		if !collection.is_owner_or_admin(sender) {
 			ensure!(
@@ -390,7 +390,7 @@
 		spender: &T::CrossAccountId,
 		amount: u128,
 	) -> DispatchResult {
-		collection.check_is_read_only()?;
+		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
@@ -336,7 +336,7 @@
 		sender: &T::CrossAccountId,
 		token: TokenId,
 	) -> DispatchResult {
-		collection.check_is_read_only()?;
+		collection.check_is_mutable()?;
 
 		let token_data =
 			<TokenData<T>>::get((collection.id, token)).ok_or(<CommonError<T>>::TokenNotFound)?;
@@ -458,7 +458,7 @@
 			&property.key,
 			is_token_create,
 		)?;
-		collection.check_is_read_only()?;
+		collection.check_is_mutable()?;
 
 		<TokenProperties<T>>::try_mutate((collection.id, token_id), |properties| {
 			let property = property.clone();
@@ -496,8 +496,8 @@
 		token_id: TokenId,
 		property_key: PropertyKey,
 	) -> DispatchResult {
+		collection.check_is_mutable()?;
 		Self::check_token_change_permission(collection, sender, token_id, &property_key, false)?;
-		collection.check_is_read_only()?;
 
 		<TokenProperties<T>>::try_mutate((collection.id, token_id), |properties| {
 			properties.remove(&property_key)
@@ -574,7 +574,7 @@
 		token_id: TokenId,
 		property_keys: Vec<PropertyKey>,
 	) -> DispatchResult {
-		collection.check_is_read_only()?;
+		collection.check_is_mutable()?;
 
 		for key in property_keys {
 			Self::delete_token_property(collection, sender, token_id, key)?;
@@ -622,7 +622,7 @@
 		token: TokenId,
 		nesting_budget: &dyn Budget,
 	) -> DispatchResult {
-		collection.check_is_read_only()?;
+		collection.check_is_mutable()?;
 
 		ensure!(
 			collection.limits.transfers_enabled(),
@@ -902,7 +902,7 @@
 		token: TokenId,
 		spender: Option<&T::CrossAccountId>,
 	) -> DispatchResult {
-		collection.check_is_read_only()?;
+		collection.check_is_mutable()?;
 
 		if collection.permissions.access() == AccessMode::AllowList {
 			collection.check_allowlist(sender)?;

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

--- 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_read_only()?;
+			collection.check_is_mutable()?;
 
 			// =========
 
@@ -407,7 +407,7 @@
 			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);
 
 			let mut target_collection = <CollectionHandle<T>>::try_get(collection_id)?;
-			target_collection.check_is_read_only()?;
+			target_collection.check_is_mutable()?;
 			target_collection.check_is_owner(&sender)?;
 
 			target_collection.owner = new_owner.clone();

--- a/primitives/data-structs/src/lib.rs
+++ b/primitives/data-structs/src/lib.rs
@@ -316,8 +316,9 @@
 	#[version(2.., upper(Default::default()))]
 	pub permissions: CollectionPermissions,
 
+	/// Marks that this collection is not "unique", and managed from external.
 	#[version(2.., upper(false))]
-	pub read_only: bool,
+	pub external_collection: bool,
 
 	#[version(..2)]
 	pub variable_on_chain_schema: BoundedVec<u8, ConstU32<VARIABLE_ON_CHAIN_SCHEMA_LIMIT>>,