git.delta.rocks / unique-network / refs/commits / 6be1bb56d5e4

difftreelog

feat split large fields out of Collection

Yaroslav Bolyukin2022-04-07parent: #3db55eb.patch.diff
in: master

7 files changed

modifiedclient/rpc/src/lib.rsdiffbeforeafterboth
--- a/client/rpc/src/lib.rs
+++ b/client/rpc/src/lib.rs
@@ -19,7 +19,7 @@
 use codec::Decode;
 use jsonrpc_core::{Error as RpcError, ErrorCode, Result};
 use jsonrpc_derive::rpc;
-use up_data_structs::{Collection, CollectionId, CollectionStats, CollectionLimits, TokenId};
+use up_data_structs::{RpcCollection, Collection, CollectionId, CollectionStats, CollectionLimits, TokenId};
 use sp_api::{BlockId, BlockT, ProvideRuntimeApi, ApiExt};
 use sp_blockchain::HeaderBackend;
 use up_rpc::UniqueApi as UniqueRuntimeApi;
@@ -116,7 +116,7 @@
 		&self,
 		collection: CollectionId,
 		at: Option<BlockHash>,
-	) -> Result<Option<Collection<AccountId>>>;
+	) -> Result<Option<RpcCollection<AccountId>>>;
 	#[rpc(name = "unique_collectionStats")]
 	fn collection_stats(&self, at: Option<BlockHash>) -> Result<CollectionStats>;
 
@@ -235,7 +235,7 @@
 	pass_method!(allowlist(collection: CollectionId) -> Vec<CrossAccountId>);
 	pass_method!(allowed(collection: CollectionId, user: CrossAccountId) -> bool);
 	pass_method!(last_token_id(collection: CollectionId) -> TokenId);
-	pass_method!(collection_by_id(collection: CollectionId) -> Option<Collection<AccountId>>);
+	pass_method!(collection_by_id(collection: CollectionId) -> Option<RpcCollection<AccountId>>);
 	pass_method!(collection_stats() -> CollectionStats);
 	pass_method!(next_sponsored(collection: CollectionId, account: CrossAccountId, token: TokenId) -> Option<u64>);
 	pass_method!(effective_collection_limits(collection_id: CollectionId) -> Option<CollectionLimits>);
modifiedpallets/common/src/lib.rsdiffbeforeafterboth
--- a/pallets/common/src/lib.rs
+++ b/pallets/common/src/lib.rs
@@ -29,11 +29,11 @@
 };
 use pallet_evm::GasWeightMapping;
 use up_data_structs::{
-	COLLECTION_NUMBER_LIMIT, Collection, CollectionId, CreateItemData, MAX_TOKEN_PREFIX_LENGTH,
+	COLLECTION_NUMBER_LIMIT, Collection, RpcCollection, CollectionId, CreateItemData, MAX_TOKEN_PREFIX_LENGTH,
 	COLLECTION_ADMINS_LIMIT, MetaUpdatePermission, TokenId, CollectionStats, MAX_TOKEN_OWNERSHIP,
 	CollectionMode, NFT_SPONSOR_TRANSFER_TIMEOUT, FUNGIBLE_SPONSOR_TRANSFER_TIMEOUT,
 	REFUNGIBLE_SPONSOR_TRANSFER_TIMEOUT, MAX_SPONSOR_TIMEOUT, CUSTOM_DATA_LIMIT, CollectionLimits,
-	CustomDataLimit, CreateCollectionData, SponsorshipState, CreateItemExData, SponsoringRateLimit, budget::Budget,
+	CustomDataLimit, CreateCollectionData, SponsorshipState, CreateItemExData, SponsoringRateLimit, budget::Budget, COLLECTION_FIELD_LIMIT, CollectionField,
 };
 pub use pallet::*;
 use sp_core::H160;
@@ -352,6 +352,9 @@
 		OnlyOwnerAllowedToNest,
 		/// Only tokens from specific collections may nest tokens under this
 		SourceCollectionIsNotAllowedToNest,
+
+		/// Tried to store more data than allowed in collection field
+		CollectionFieldSizeExceeded,
 	}
 
 	#[pallet::storage]
@@ -369,6 +372,17 @@
 		QueryKind = OptionQuery,
 	>;
 
+	/// Large variable-size collection fields are extracted here
+	#[pallet::storage]
+	pub type CollectionData<T> = StorageNMap<
+		Key = (
+			Key<Twox64Concat, CollectionId>,
+			Key<Twox64Concat, CollectionField>,
+		),
+		Value = BoundedVec<u8, ConstU32<COLLECTION_FIELD_LIMIT>>,
+		QueryKind = ValueQuery,
+	>;
+
 	#[pallet::storage]
 	pub type AdminAmount<T> = StorageMap<
 		Hasher = Blake2_128Concat,
@@ -409,7 +423,26 @@
 		fn on_runtime_upgrade() -> Weight {
 			if StorageVersion::get::<Pallet<T>>() < StorageVersion::new(1) {
 				use up_data_structs::{CollectionVersion1, CollectionVersion2};
-				<CollectionById<T>>::translate_values::<CollectionVersion1<T::AccountId>, _>(|v| {
+				<CollectionById<T>>::translate::<CollectionVersion1<T::AccountId>, _>(|id, v| {
+					Self::set_field_raw(
+						id,
+						CollectionField::OffchainSchema,
+						v.offchain_schema.clone().into_inner(),
+					)
+					.expect("data has lower bounds than field");
+					Self::set_field_raw(
+						id,
+						CollectionField::VariableOnChainSchema,
+						v.variable_on_chain_schema.clone().into_inner(),
+					)
+					.expect("data has lower bounds than field");
+					Self::set_field_raw(
+						id,
+						CollectionField::ConstOnChainSchema,
+						v.const_on_chain_schema.clone().into_inner(),
+					)
+					.expect("data has lower bounds than field");
+
 					Some(CollectionVersion2::from(v))
 				});
 			}
@@ -483,6 +516,50 @@
 
 		Some(effective_limits)
 	}
+
+	pub fn rpc_collection(collection: CollectionId) -> Option<RpcCollection<T::AccountId>> {
+		let Collection {
+			name,
+			description,
+			owner,
+			mode,
+			access,
+			token_prefix,
+			mint_mode,
+			schema_version,
+			sponsorship,
+			limits,
+			meta_update_permission,
+		} = <CollectionById<T>>::get(collection)?;
+		Some(RpcCollection {
+			name: name.into_inner(),
+			description: description.into_inner(),
+			owner,
+			mode,
+			access,
+			token_prefix: token_prefix.into_inner(),
+			mint_mode,
+			schema_version,
+			sponsorship,
+			limits,
+			meta_update_permission,
+			offchain_schema: <CollectionData<T>>::get((
+				collection,
+				CollectionField::OffchainSchema,
+			))
+			.into_inner(),
+			const_on_chain_schema: <CollectionData<T>>::get((
+				collection,
+				CollectionField::ConstOnChainSchema,
+			))
+			.into_inner(),
+			variable_on_chain_schema: <CollectionData<T>>::get((
+				collection,
+				CollectionField::VariableOnChainSchema,
+			))
+			.into_inner(),
+		})
+	}
 }
 
 impl<T: Config> Pallet<T> {
@@ -520,14 +597,11 @@
 			access: data.access.unwrap_or_default(),
 			description: data.description,
 			token_prefix: data.token_prefix,
-			offchain_schema: data.offchain_schema,
 			schema_version: data.schema_version.unwrap_or_default(),
 			sponsorship: data
 				.pending_sponsor
 				.map(SponsorshipState::Unconfirmed)
 				.unwrap_or_default(),
-			variable_on_chain_schema: data.variable_on_chain_schema,
-			const_on_chain_schema: data.const_on_chain_schema,
 			limits: data
 				.limits
 				.map(|limits| Self::clamp_limits(data.mode.clone(), &Default::default(), limits))
@@ -557,6 +631,24 @@
 		<CreatedCollectionCount<T>>::put(created_count);
 		<Pallet<T>>::deposit_event(Event::CollectionCreated(id, data.mode.id(), owner.clone()));
 		<CollectionById<T>>::insert(id, collection);
+		Self::set_field_raw(
+			id,
+			CollectionField::OffchainSchema,
+			data.offchain_schema.into_inner(),
+		)
+		.expect("data has lower bounds than field");
+		Self::set_field_raw(
+			id,
+			CollectionField::VariableOnChainSchema,
+			data.variable_on_chain_schema.into_inner(),
+		)
+		.expect("data has lower bounds than field");
+		Self::set_field_raw(
+			id,
+			CollectionField::ConstOnChainSchema,
+			data.const_on_chain_schema.into_inner(),
+		)
+		.expect("data has lower bounds than field");
 		Ok(id)
 	}
 
@@ -579,6 +671,7 @@
 
 		<DestroyedCollectionCount<T>>::put(destroyed_collections);
 		<CollectionById<T>>::remove(collection.id);
+		<CollectionData<T>>::remove_prefix((collection.id,), None);
 		<AdminAmount<T>>::remove(collection.id);
 		<IsAdmin<T>>::remove_prefix((collection.id,), None);
 		<Allowlist<T>>::remove_prefix((collection.id,), None);
@@ -587,6 +680,35 @@
 		Ok(())
 	}
 
+	fn set_field_raw(
+		collection_id: CollectionId,
+		field: CollectionField,
+		value: Vec<u8>,
+	) -> DispatchResult {
+		if !value.is_empty() {
+			<CollectionData<T>>::insert(
+				(collection_id, field),
+				BoundedVec::try_from(value).map_err(|_| <Error<T>>::CollectionFieldSizeExceeded)?,
+			)
+		} else {
+			<CollectionData<T>>::remove((collection_id, field));
+		}
+		Ok(())
+	}
+
+	pub fn set_field(
+		collection: &CollectionHandle<T>,
+		sender: &T::CrossAccountId,
+		field: CollectionField,
+		value: Vec<u8>,
+	) -> DispatchResult {
+		collection.check_is_owner_or_admin(sender)?;
+
+		// =========
+
+		Self::set_field_raw(collection.id, field, value)
+	}
+
 	pub fn toggle_allowlist(
 		collection: &CollectionHandle<T>,
 		sender: &T::CrossAccountId,
modifiedpallets/unique/src/lib.rsdiffbeforeafterboth
43	MAX_COLLECTION_NAME_LENGTH, MAX_COLLECTION_DESCRIPTION_LENGTH, MAX_TOKEN_PREFIX_LENGTH,43	MAX_COLLECTION_NAME_LENGTH, MAX_COLLECTION_DESCRIPTION_LENGTH, MAX_TOKEN_PREFIX_LENGTH,
44	AccessMode, CreateItemData, CollectionLimits, CollectionId, CollectionMode, TokenId,44	AccessMode, CreateItemData, CollectionLimits, CollectionId, CollectionMode, TokenId,
45	SchemaVersion, SponsorshipState, MetaUpdatePermission, CreateCollectionData, CustomDataLimit,45	SchemaVersion, SponsorshipState, MetaUpdatePermission, CreateCollectionData, CustomDataLimit,
46	CreateItemExData, budget,46	CreateItemExData, budget, CollectionField,
47};47};
48use pallet_evm::account::CrossAccountId;48use pallet_evm::account::CrossAccountId;
49use pallet_common::{49use pallet_common::{
1004			schema: BoundedVec<u8, ConstU32<OFFCHAIN_SCHEMA_LIMIT>>,1004			schema: BoundedVec<u8, ConstU32<OFFCHAIN_SCHEMA_LIMIT>>,
1005		) -> DispatchResult {1005		) -> DispatchResult {
1006			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1006			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);
1007			let mut target_collection = <CollectionHandle<T>>::try_get(collection_id)?;1007			let collection = <CollectionHandle<T>>::try_get(collection_id)?;
1008
1009			// =========
1010
1008			target_collection.check_is_owner_or_admin(&sender)?;1011			<PalletCommon<T>>::set_field(&collection, &sender, CollectionField::OffchainSchema, schema.into_inner())?;
1009
1010			target_collection.offchain_schema = schema;
10111012
1012			<Pallet<T>>::deposit_event(Event::<T>::OffchainSchemaSet(1013			<Pallet<T>>::deposit_event(Event::<T>::OffchainSchemaSet(
1013				collection_id1014				collection_id
1014			));1015			));
1015
1016			target_collection.save()1016			Ok(())
1017		}1017		}
10181018
1019		/// Set const on-chain data schema.1019		/// Set const on-chain data schema.
1036			schema: BoundedVec<u8, ConstU32<CONST_ON_CHAIN_SCHEMA_LIMIT>>1036			schema: BoundedVec<u8, ConstU32<CONST_ON_CHAIN_SCHEMA_LIMIT>>
1037		) -> DispatchResult {1037		) -> DispatchResult {
1038			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1038			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);
1039			let mut target_collection = <CollectionHandle<T>>::try_get(collection_id)?;1039			let collection = <CollectionHandle<T>>::try_get(collection_id)?;
1040
1041			// =========
1042
1040			target_collection.check_is_owner_or_admin(&sender)?;1043			<PalletCommon<T>>::set_field(&collection, &sender, CollectionField::ConstOnChainSchema, schema.into_inner())?;
1041
1042			target_collection.const_on_chain_schema = schema;
10431044
1044			<Pallet<T>>::deposit_event(Event::<T>::ConstOnChainSchemaSet(1045			<Pallet<T>>::deposit_event(Event::<T>::ConstOnChainSchemaSet(
1045				collection_id1046				collection_id
1046			));1047			));
1047
1048			target_collection.save()1048			Ok(())
1049		}1049		}
10501050
1051		/// Set variable on-chain data schema.1051		/// Set variable on-chain data schema.
1068			schema: BoundedVec<u8, ConstU32<VARIABLE_ON_CHAIN_SCHEMA_LIMIT>>1068			schema: BoundedVec<u8, ConstU32<VARIABLE_ON_CHAIN_SCHEMA_LIMIT>>
1069		) -> DispatchResult {1069		) -> DispatchResult {
1070			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1070			let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);
1071			let mut target_collection = <CollectionHandle<T>>::try_get(collection_id)?;1071			let collection = <CollectionHandle<T>>::try_get(collection_id)?;
1072
1073			// =========
1074
1072			target_collection.check_is_owner_or_admin(&sender)?;1075			<PalletCommon<T>>::set_field(&collection, &sender, CollectionField::VariableOnChainSchema, schema.into_inner())?;
1073
1074			target_collection.variable_on_chain_schema = schema;
10751076
1076			<Pallet<T>>::deposit_event(Event::<T>::VariableOnChainSchemaSet(1077			<Pallet<T>>::deposit_event(Event::<T>::VariableOnChainSchemaSet(
1077				collection_id1078				collection_id
1078			));1079			));
1079
1080			target_collection.save()1080			Ok(())
1081		}1081		}
10821082
1083		#[weight = <SelfWeightOf<T>>::set_collection_limits()]1083		#[weight = <SelfWeightOf<T>>::set_collection_limits()]
modifiedprimitives/data-structs/src/lib.rsdiffbeforeafterboth
--- a/primitives/data-structs/src/lib.rs
+++ b/primitives/data-structs/src/lib.rs
@@ -78,6 +78,9 @@
 pub const VARIABLE_ON_CHAIN_SCHEMA_LIMIT: u32 = 8192;
 pub const CONST_ON_CHAIN_SCHEMA_LIMIT: u32 = 32768;
 
+pub const COLLECTION_FIELD_LIMIT: u32 = CONST_ON_CHAIN_SCHEMA_LIMIT;
+// u32::max is not const: OFFCHAIN_SCHEMA_LIMIT.max(VARIABLE_ON_CHAIN_SCHEMA_LIMIT).max(CONST_ON_CHAIN_SCHEMA_LIMIT);
+
 pub const MAX_COLLECTION_NAME_LENGTH: u32 = 64;
 pub const MAX_COLLECTION_DESCRIPTION_LENGTH: u32 = 256;
 pub const MAX_TOKEN_PREFIX_LENGTH: u32 = 16;
@@ -248,22 +251,21 @@
 	}
 }
 
+/// Used in storage
 #[struct_versioning::versioned(version = 2, upper)]
 #[derive(Encode, Decode, Clone, PartialEq, TypeInfo, MaxEncodedLen)]
-#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]
 pub struct Collection<AccountId> {
 	pub owner: AccountId,
 	pub mode: CollectionMode,
 	pub access: AccessMode,
-	#[cfg_attr(feature = "serde1", serde(with = "bounded::vec_serde"))]
 	pub name: BoundedVec<u16, ConstU32<MAX_COLLECTION_NAME_LENGTH>>,
-	#[cfg_attr(feature = "serde1", serde(with = "bounded::vec_serde"))]
 	pub description: BoundedVec<u16, ConstU32<MAX_COLLECTION_DESCRIPTION_LENGTH>>,
-	#[cfg_attr(feature = "serde1", serde(with = "bounded::vec_serde"))]
 	pub token_prefix: BoundedVec<u8, ConstU32<MAX_TOKEN_PREFIX_LENGTH>>,
 	pub mint_mode: bool,
-	#[cfg_attr(feature = "serde1", serde(with = "bounded::vec_serde"))]
+
+	#[version(..2)]
 	pub offchain_schema: BoundedVec<u8, ConstU32<OFFCHAIN_SCHEMA_LIMIT>>,
+
 	pub schema_version: SchemaVersion,
 	pub sponsorship: SponsorshipState<AccountId>,
 
@@ -272,13 +274,42 @@
 	#[version(2.., upper(limits.into()))]
 	pub limits: CollectionLimitsVersion2,
 
-	#[cfg_attr(feature = "serde1", serde(with = "bounded::vec_serde"))]
+	#[version(..2)]
 	pub variable_on_chain_schema: BoundedVec<u8, ConstU32<VARIABLE_ON_CHAIN_SCHEMA_LIMIT>>,
-	#[cfg_attr(feature = "serde1", serde(with = "bounded::vec_serde"))]
+	#[version(..2)]
 	pub const_on_chain_schema: BoundedVec<u8, ConstU32<CONST_ON_CHAIN_SCHEMA_LIMIT>>,
+
 	pub meta_update_permission: MetaUpdatePermission,
 }
 
+/// Used in RPC calls
+#[derive(Encode, Decode, Clone, PartialEq, TypeInfo)]
+#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]
+pub struct RpcCollection<AccountId> {
+	pub owner: AccountId,
+	pub mode: CollectionMode,
+	pub access: AccessMode,
+	pub name: Vec<u16>,
+	pub description: Vec<u16>,
+	pub token_prefix: Vec<u8>,
+	pub mint_mode: bool,
+	pub offchain_schema: Vec<u8>,
+	pub schema_version: SchemaVersion,
+	pub sponsorship: SponsorshipState<AccountId>,
+	pub limits: CollectionLimits,
+	pub variable_on_chain_schema: Vec<u8>,
+	pub const_on_chain_schema: Vec<u8>,
+	pub meta_update_permission: MetaUpdatePermission,
+}
+
+#[derive(Encode, Decode, Clone, PartialEq, TypeInfo, MaxEncodedLen)]
+#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]
+pub enum CollectionField {
+	VariableOnChainSchema,
+	ConstOnChainSchema,
+	OffchainSchema,
+}
+
 #[derive(Encode, Decode, Clone, PartialEq, TypeInfo, Debug, Derivative, MaxEncodedLen)]
 #[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]
 #[derivative(Default(bound = ""))]
modifiedprimitives/rpc/src/lib.rsdiffbeforeafterboth
--- a/primitives/rpc/src/lib.rs
+++ b/primitives/rpc/src/lib.rs
@@ -16,7 +16,7 @@
 
 #![cfg_attr(not(feature = "std"), no_std)]
 
-use up_data_structs::{CollectionId, TokenId, Collection, CollectionStats, CollectionLimits};
+use up_data_structs::{CollectionId, TokenId, RpcCollection, Collection, CollectionStats, CollectionLimits};
 use sp_std::vec::Vec;
 use codec::Decode;
 use sp_runtime::DispatchError;
@@ -53,7 +53,7 @@
 		fn allowlist(collection: CollectionId) -> Result<Vec<CrossAccountId>>;
 		fn allowed(collection: CollectionId, user: CrossAccountId) -> Result<bool>;
 		fn last_token_id(collection: CollectionId) -> Result<TokenId>;
-		fn collection_by_id(collection: CollectionId) -> Result<Option<Collection<AccountId>>>;
+		fn collection_by_id(collection: CollectionId) -> Result<Option<RpcCollection<AccountId>>>;
 		fn collection_stats() -> Result<CollectionStats>;
 		fn next_sponsored(collection: CollectionId, account: CrossAccountId, token: TokenId) -> Result<Option<u64>>;
 		fn effective_collection_limits(collection_id: CollectionId) -> Result<Option<CollectionLimits>>;
modifiedruntime/common/src/runtime_apis.rsdiffbeforeafterboth
--- a/runtime/common/src/runtime_apis.rs
+++ b/runtime/common/src/runtime_apis.rs
@@ -58,8 +58,8 @@
                 fn last_token_id(collection: CollectionId) -> Result<TokenId, DispatchError> {
                     dispatch_unique_runtime!(collection.last_token_id())
                 }
-                fn collection_by_id(collection: CollectionId) -> Result<Option<Collection<AccountId>>, DispatchError> {
-                    Ok(<pallet_common::CollectionById<Runtime>>::get(collection))
+                fn collection_by_id(collection: CollectionId) -> Result<Option<RpcCollection<AccountId>>, DispatchError> {
+                    Ok(<pallet_common::Pallet<Runtime>>::rpc_collection(collection))
                 }
                 fn collection_stats() -> Result<CollectionStats, DispatchError> {
                     Ok(<pallet_common::Pallet<Runtime>>::collection_stats())
modifiedruntime/opal/src/lib.rsdiffbeforeafterboth
--- a/runtime/opal/src/lib.rs
+++ b/runtime/opal/src/lib.rs
@@ -67,7 +67,7 @@
 	},
 };
 use up_data_structs::mapping::{EvmTokenAddressMapping, CrossTokenAddressMapping};
-use up_data_structs::{CollectionId, TokenId, CollectionStats, Collection};
+use up_data_structs::{CollectionId, TokenId, CollectionStats, Collection, RpcCollection};
 // use pallet_contracts::weights::WeightInfo;
 // #[cfg(any(feature = "std", test))]
 use frame_system::{