git.delta.rocks / unique-network / refs/commits / 7f8cc7f16d35

difftreelog

Merge pull request #294 from UniqueNetwork/feature/create-collection-ex

kozyrevdev2022-02-24parents: #b4099fe #1141b20.patch.diff
in: master
Remove double option limit

6 files changed

modifiedprimitives/data-structs/src/lib.rsdiffbeforeafterboth
after · primitives/data-structs/src/lib.rs
1#![cfg_attr(not(feature = "std"), no_std)]23use core::convert::{TryFrom, TryInto};45#[cfg(feature = "serde")]6pub use serde::{Serialize, Deserialize};78use sp_core::U256;9use sp_runtime::{ArithmeticError, sp_std::prelude::Vec};10use codec::{Decode, Encode, EncodeLike, MaxEncodedLen};11pub use frame_support::{12	BoundedVec, construct_runtime, decl_event, decl_module, decl_storage, decl_error,13	dispatch::DispatchResult,14	ensure, fail, parameter_types,15	traits::{16		Currency, ExistenceRequirement, Get, Imbalance, KeyOwnerProofSystem, OnUnbalanced,17		Randomness, IsSubType, WithdrawReasons,18	},19	weights::{20		constants::{BlockExecutionWeight, ExtrinsicBaseWeight, RocksDbWeight, WEIGHT_PER_SECOND},21		DispatchInfo, GetDispatchInfo, IdentityFee, Pays, PostDispatchInfo, Weight,22		WeightToFeePolynomial, DispatchClass,23	},24	StorageValue, transactional,25	pallet_prelude::ConstU32,26};27use derivative::Derivative;28use scale_info::TypeInfo;2930mod migration;3132pub const MAX_DECIMAL_POINTS: DecimalPoints = 30;33pub const MAX_REFUNGIBLE_PIECES: u128 = 1_000_000_000_000_000_000_000;34pub const MAX_SPONSOR_TIMEOUT: u32 = 10_368_000;3536pub const MAX_TOKEN_OWNERSHIP: u32 = if cfg!(not(feature = "limit-testing")) {37	100_00038} else {39	1040};41pub const COLLECTION_NUMBER_LIMIT: u32 = if cfg!(not(feature = "limit-testing")) {42	100_00043} else {44	1045};46pub const CUSTOM_DATA_LIMIT: u32 = if cfg!(not(feature = "limit-testing")) {47	204848} else {49	1050};51pub const COLLECTION_ADMINS_LIMIT: u32 = 5;52pub const COLLECTION_TOKEN_LIMIT: u32 = u32::MAX;53pub const ACCOUNT_TOKEN_OWNERSHIP_LIMIT: u32 = if cfg!(not(feature = "limit-testing")) {54	1_000_00055} else {56	1057};5859// Timeouts for item types in passed blocks60pub const NFT_SPONSOR_TRANSFER_TIMEOUT: u32 = 5;61pub const FUNGIBLE_SPONSOR_TRANSFER_TIMEOUT: u32 = 5;62pub const REFUNGIBLE_SPONSOR_TRANSFER_TIMEOUT: u32 = 5;6364pub const SPONSOR_APPROVE_TIMEOUT: u32 = 5;6566// Schema limits67pub const OFFCHAIN_SCHEMA_LIMIT: u32 = 8192;68pub const VARIABLE_ON_CHAIN_SCHEMA_LIMIT: u32 = 8192;69pub const CONST_ON_CHAIN_SCHEMA_LIMIT: u32 = 32768;7071pub const MAX_COLLECTION_NAME_LENGTH: u32 = 64;72pub const MAX_COLLECTION_DESCRIPTION_LENGTH: u32 = 256;73pub const MAX_TOKEN_PREFIX_LENGTH: u32 = 16;7475/// How much items can be created per single76/// create_many call77pub const MAX_ITEMS_PER_BATCH: u32 = 200;7879parameter_types! {80	pub const CustomDataLimit: u32 = CUSTOM_DATA_LIMIT;81}8283#[derive(84	Encode,85	Decode,86	PartialEq,87	Eq,88	PartialOrd,89	Ord,90	Clone,91	Copy,92	Debug,93	Default,94	TypeInfo,95	MaxEncodedLen,96)]97#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]98pub struct CollectionId(pub u32);99impl EncodeLike<u32> for CollectionId {}100impl EncodeLike<CollectionId> for u32 {}101102#[derive(103	Encode,104	Decode,105	PartialEq,106	Eq,107	PartialOrd,108	Ord,109	Clone,110	Copy,111	Debug,112	Default,113	TypeInfo,114	MaxEncodedLen,115)]116#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]117pub struct TokenId(pub u32);118impl EncodeLike<u32> for TokenId {}119impl EncodeLike<TokenId> for u32 {}120121impl TokenId {122	pub fn try_next(self) -> Result<TokenId, ArithmeticError> {123		self.0124			.checked_add(1)125			.ok_or(ArithmeticError::Overflow)126			.map(Self)127	}128}129130impl From<TokenId> for U256 {131	fn from(t: TokenId) -> Self {132		t.0.into()133	}134}135136impl TryFrom<U256> for TokenId {137	type Error = &'static str;138139	fn try_from(value: U256) -> Result<Self, Self::Error> {140		Ok(TokenId(value.try_into().map_err(|_| "too large token id")?))141	}142}143144pub struct OverflowError;145impl From<OverflowError> for &'static str {146	fn from(_: OverflowError) -> Self {147		"overflow occured"148	}149}150151pub type DecimalPoints = u8;152153#[derive(Encode, Decode, Eq, Debug, Clone, PartialEq, TypeInfo, MaxEncodedLen)]154#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]155pub enum CollectionMode {156	NFT,157	// decimal points158	Fungible(DecimalPoints),159	ReFungible,160}161162impl CollectionMode {163	pub fn id(&self) -> u8 {164		match self {165			CollectionMode::NFT => 1,166			CollectionMode::Fungible(_) => 2,167			CollectionMode::ReFungible => 3,168		}169	}170}171172pub trait SponsoringResolve<AccountId, Call> {173	fn resolve(who: &AccountId, call: &Call) -> Option<AccountId>;174}175176#[derive(Encode, Decode, Eq, Debug, Clone, PartialEq, TypeInfo, MaxEncodedLen)]177#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]178pub enum AccessMode {179	Normal,180	AllowList,181}182impl Default for AccessMode {183	fn default() -> Self {184		Self::Normal185	}186}187188#[derive(Encode, Decode, Eq, Debug, Clone, PartialEq, TypeInfo, MaxEncodedLen)]189#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]190pub enum SchemaVersion {191	ImageURL,192	Unique,193}194impl Default for SchemaVersion {195	fn default() -> Self {196		Self::ImageURL197	}198}199200#[derive(Encode, Decode, Default, Debug, Clone, PartialEq, TypeInfo)]201#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]202pub struct Ownership<AccountId> {203	pub owner: AccountId,204	pub fraction: u128,205}206207#[derive(Encode, Decode, Debug, Clone, PartialEq, TypeInfo, MaxEncodedLen)]208#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]209pub enum SponsorshipState<AccountId> {210	/// The fees are applied to the transaction sender211	Disabled,212	Unconfirmed(AccountId),213	/// Transactions are sponsored by specified account214	Confirmed(AccountId),215}216217impl<AccountId> SponsorshipState<AccountId> {218	pub fn sponsor(&self) -> Option<&AccountId> {219		match self {220			Self::Confirmed(sponsor) => Some(sponsor),221			_ => None,222		}223	}224225	pub fn pending_sponsor(&self) -> Option<&AccountId> {226		match self {227			Self::Unconfirmed(sponsor) | Self::Confirmed(sponsor) => Some(sponsor),228			_ => None,229		}230	}231232	pub fn confirmed(&self) -> bool {233		matches!(self, Self::Confirmed(_))234	}235}236237impl<T> Default for SponsorshipState<T> {238	fn default() -> Self {239		Self::Disabled240	}241}242243#[derive(Encode, Decode, Clone, PartialEq, TypeInfo, MaxEncodedLen)]244#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]245pub struct Collection<AccountId> {246	pub owner: AccountId,247	pub mode: CollectionMode,248	pub access: AccessMode,249	#[cfg_attr(feature = "serde1", serde(with = "bounded_serde"))]250	pub name: BoundedVec<u16, ConstU32<MAX_COLLECTION_NAME_LENGTH>>,251	#[cfg_attr(feature = "serde1", serde(with = "bounded_serde"))]252	pub description: BoundedVec<u16, ConstU32<MAX_COLLECTION_DESCRIPTION_LENGTH>>,253	#[cfg_attr(feature = "serde1", serde(with = "bounded_serde"))]254	pub token_prefix: BoundedVec<u8, ConstU32<MAX_TOKEN_PREFIX_LENGTH>>,255	pub mint_mode: bool,256	#[cfg_attr(feature = "serde1", serde(with = "bounded_serde"))]257	pub offchain_schema: BoundedVec<u8, ConstU32<OFFCHAIN_SCHEMA_LIMIT>>,258	pub schema_version: SchemaVersion,259	pub sponsorship: SponsorshipState<AccountId>,260	pub limits: CollectionLimits, // Collection private restrictions261	#[cfg_attr(feature = "serde1", serde(with = "bounded_serde"))]262	pub variable_on_chain_schema: BoundedVec<u8, ConstU32<VARIABLE_ON_CHAIN_SCHEMA_LIMIT>>,263	#[cfg_attr(feature = "serde1", serde(with = "bounded_serde"))]264	pub const_on_chain_schema: BoundedVec<u8, ConstU32<CONST_ON_CHAIN_SCHEMA_LIMIT>>,265	pub meta_update_permission: MetaUpdatePermission,266}267268#[derive(Encode, Decode, Clone, PartialEq, TypeInfo, Debug, Derivative, MaxEncodedLen)]269#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]270#[derivative(Default(bound = ""))]271pub struct CreateCollectionData<AccountId> {272	#[derivative(Default(value = "CollectionMode::NFT"))]273	pub mode: CollectionMode,274	pub access: Option<AccessMode>,275	#[cfg_attr(feature = "serde1", serde(with = "bounded_serde"))]276	pub name: BoundedVec<u16, ConstU32<MAX_COLLECTION_NAME_LENGTH>>,277	#[cfg_attr(feature = "serde1", serde(with = "bounded_serde"))]278	pub description: BoundedVec<u16, ConstU32<MAX_COLLECTION_DESCRIPTION_LENGTH>>,279	#[cfg_attr(feature = "serde1", serde(with = "bounded_serde"))]280	pub token_prefix: BoundedVec<u8, ConstU32<MAX_TOKEN_PREFIX_LENGTH>>,281	#[cfg_attr(feature = "serde1", serde(with = "bounded_serde"))]282	pub offchain_schema: BoundedVec<u8, ConstU32<OFFCHAIN_SCHEMA_LIMIT>>,283	pub schema_version: Option<SchemaVersion>,284	pub pending_sponsor: Option<AccountId>,285	pub limits: Option<CollectionLimits>,286	#[cfg_attr(feature = "serde1", serde(with = "bounded_serde"))]287	pub variable_on_chain_schema: BoundedVec<u8, ConstU32<VARIABLE_ON_CHAIN_SCHEMA_LIMIT>>,288	#[cfg_attr(feature = "serde1", serde(with = "bounded_serde"))]289	pub const_on_chain_schema: BoundedVec<u8, ConstU32<CONST_ON_CHAIN_SCHEMA_LIMIT>>,290	pub meta_update_permission: Option<MetaUpdatePermission>,291}292293#[derive(Encode, Decode, Debug, Clone, PartialEq, TypeInfo)]294#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]295pub struct NftItemType<AccountId> {296	pub owner: AccountId,297	pub const_data: Vec<u8>,298	pub variable_data: Vec<u8>,299}300301#[derive(Encode, Decode, Default, Debug, Clone, PartialEq, TypeInfo)]302#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]303pub struct FungibleItemType {304	pub value: u128,305}306307#[derive(Encode, Decode, Debug, Clone, PartialEq, TypeInfo)]308#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]309pub struct ReFungibleItemType<AccountId> {310	pub owner: Vec<Ownership<AccountId>>,311	pub const_data: Vec<u8>,312	pub variable_data: Vec<u8>,313}314315/// All fields are wrapped in `Option`s, where None means chain default316#[derive(Encode, Decode, Debug, Default, Clone, PartialEq, TypeInfo, MaxEncodedLen)]317#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]318pub struct CollectionLimits {319	pub account_token_ownership_limit: Option<u32>,320	pub sponsored_data_size: Option<u32>,321	/// None - setVariableMetadata is not sponsored322	/// Some(v) - setVariableMetadata is sponsored323	///           if there is v block between txs324	pub sponsored_data_rate_limit: Option<SponsoringRateLimit>,325	pub token_limit: Option<u32>,326327	// Timeouts for item types in passed blocks328	pub sponsor_transfer_timeout: Option<u32>,329	pub sponsor_approve_timeout: Option<u32>,330	pub owner_can_transfer: Option<bool>,331	pub owner_can_destroy: Option<bool>,332	pub transfers_enabled: Option<bool>,333}334335impl CollectionLimits {336	pub fn account_token_ownership_limit(&self) -> u32 {337		self.account_token_ownership_limit338			.unwrap_or(ACCOUNT_TOKEN_OWNERSHIP_LIMIT)339			.min(MAX_TOKEN_OWNERSHIP)340	}341	pub fn sponsored_data_size(&self) -> u32 {342		self.sponsored_data_size343			.unwrap_or(CUSTOM_DATA_LIMIT)344			.min(CUSTOM_DATA_LIMIT)345	}346	pub fn token_limit(&self) -> u32 {347		self.token_limit348			.unwrap_or(COLLECTION_TOKEN_LIMIT)349			.min(COLLECTION_TOKEN_LIMIT)350	}351	pub fn sponsor_transfer_timeout(&self, default: u32) -> u32 {352		self.sponsor_transfer_timeout353			.unwrap_or(default)354			.min(MAX_SPONSOR_TIMEOUT)355	}356	pub fn sponsor_approve_timeout(&self) -> u32 {357		self.sponsor_approve_timeout358			.unwrap_or(SPONSOR_APPROVE_TIMEOUT)359			.min(MAX_SPONSOR_TIMEOUT)360	}361	pub fn owner_can_transfer(&self) -> bool {362		self.owner_can_transfer.unwrap_or(true)363	}364	pub fn owner_can_destroy(&self) -> bool {365		self.owner_can_destroy.unwrap_or(true)366	}367	pub fn transfers_enabled(&self) -> bool {368		self.transfers_enabled.unwrap_or(true)369	}370	pub fn sponsored_data_rate_limit(&self) -> Option<u32> {371		match self372			.sponsored_data_rate_limit373			.unwrap_or(SponsoringRateLimit::SponsoringDisabled)374		{375			SponsoringRateLimit::SponsoringDisabled => None,376			SponsoringRateLimit::Blocks(v) => Some(v.min(MAX_SPONSOR_TIMEOUT)),377		}378	}379}380381#[derive(Encode, Decode, Debug, Clone, Copy, PartialEq, TypeInfo, MaxEncodedLen)]382#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]383pub enum SponsoringRateLimit {384	SponsoringDisabled,385	Blocks(u32),386}387388/// BoundedVec doesn't supports serde389#[cfg(feature = "serde1")]390mod bounded_serde {391	use core::convert::TryFrom;392	use frame_support::{BoundedVec, traits::Get};393	use serde::{394		ser::{self, Serialize},395		de::{self, Deserialize, Error},396	};397	use sp_std::vec::Vec;398399	pub fn serialize<D, V, S>(value: &BoundedVec<V, S>, serializer: D) -> Result<D::Ok, D::Error>400	where401		D: ser::Serializer,402		V: Serialize,403	{404		(value as &Vec<_>).serialize(serializer)405	}406407	pub fn deserialize<'de, D, V, S>(deserializer: D) -> Result<BoundedVec<V, S>, D::Error>408	where409		D: de::Deserializer<'de>,410		V: de::Deserialize<'de>,411		S: Get<u32>,412	{413		// TODO: Implement custom visitor, which will limit vec size at parse time? Will serde only be used by chainspec?414		let vec = <Vec<V>>::deserialize(deserializer)?;415		let len = vec.len();416		TryFrom::try_from(vec).map_err(|_| D::Error::invalid_length(len, &"lesser size"))417	}418}419420#[derive(Encode, Decode, MaxEncodedLen, Default, PartialEq, Clone, Derivative, TypeInfo)]421#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]422#[derivative(Debug)]423pub struct CreateNftData {424	#[cfg_attr(feature = "serde1", serde(with = "bounded_serde"))]425	#[derivative(Debug = "ignore")]426	pub const_data: BoundedVec<u8, CustomDataLimit>,427	#[cfg_attr(feature = "serde1", serde(with = "bounded_serde"))]428	#[derivative(Debug = "ignore")]429	pub variable_data: BoundedVec<u8, CustomDataLimit>,430}431432#[derive(Encode, Decode, MaxEncodedLen, Default, Debug, Clone, PartialEq, TypeInfo)]433#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]434pub struct CreateFungibleData {435	pub value: u128,436}437438#[derive(Encode, Decode, MaxEncodedLen, Default, PartialEq, Clone, Derivative, TypeInfo)]439#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]440#[derivative(Debug)]441pub struct CreateReFungibleData {442	#[cfg_attr(feature = "serde1", serde(with = "bounded_serde"))]443	#[derivative(Debug = "ignore")]444	pub const_data: BoundedVec<u8, CustomDataLimit>,445	#[cfg_attr(feature = "serde1", serde(with = "bounded_serde"))]446	#[derivative(Debug = "ignore")]447	pub variable_data: BoundedVec<u8, CustomDataLimit>,448	pub pieces: u128,449}450451#[derive(Encode, Decode, Debug, Clone, PartialEq, TypeInfo, MaxEncodedLen)]452#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]453pub enum MetaUpdatePermission {454	ItemOwner,455	Admin,456	None,457}458459impl Default for MetaUpdatePermission {460	fn default() -> Self {461		Self::ItemOwner462	}463}464465#[derive(Encode, Decode, MaxEncodedLen, PartialEq, Clone, Debug, TypeInfo)]466#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]467pub enum CreateItemData {468	NFT(CreateNftData),469	Fungible(CreateFungibleData),470	ReFungible(CreateReFungibleData),471}472473impl CreateItemData {474	pub fn data_size(&self) -> usize {475		match self {476			CreateItemData::NFT(data) => data.variable_data.len() + data.const_data.len(),477			CreateItemData::ReFungible(data) => data.variable_data.len() + data.const_data.len(),478			_ => 0,479		}480	}481}482483impl From<CreateNftData> for CreateItemData {484	fn from(item: CreateNftData) -> Self {485		CreateItemData::NFT(item)486	}487}488489impl From<CreateReFungibleData> for CreateItemData {490	fn from(item: CreateReFungibleData) -> Self {491		CreateItemData::ReFungible(item)492	}493}494495impl From<CreateFungibleData> for CreateItemData {496	fn from(item: CreateFungibleData) -> Self {497		CreateItemData::Fungible(item)498	}499}500501#[derive(Encode, Decode, MaxEncodedLen, PartialEq, Clone, Debug, TypeInfo)]502#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]503pub struct CollectionStats {504	pub created: u32,505	pub destroyed: u32,506	pub alive: u32,507}
addedprimitives/data-structs/src/migration.rsdiffbeforeafterboth
--- /dev/null
+++ b/primitives/data-structs/src/migration.rs
@@ -0,0 +1,24 @@
+/// Storage migration is not required for this change, as SponsoringRateLimit has same encoding as Option<u32>
+#[test]
+fn sponsoring_rate_limit_has_same_encoding_as_option_u32() {
+	use crate::SponsoringRateLimit;
+	use codec::Encode;
+
+	fn limit_to_option(limit: SponsoringRateLimit) -> Option<u32> {
+		match limit {
+			SponsoringRateLimit::SponsoringDisabled => None,
+			SponsoringRateLimit::Blocks(v) => Some(v),
+		}
+	}
+
+	fn test_to_option(limit: SponsoringRateLimit) {
+		let encoded = limit.encode();
+		let option = limit_to_option(limit);
+		let encoded_option = option.encode();
+
+		assert_eq!(encoded, encoded_option);
+	}
+
+	test_to_option(SponsoringRateLimit::SponsoringDisabled);
+	test_to_option(SponsoringRateLimit::Blocks(10));
+}
modifiedtests/src/interfaces/augment-types.tsdiffbeforeafterboth
--- a/tests/src/interfaces/augment-types.ts
+++ b/tests/src/interfaces/augment-types.ts
@@ -1,7 +1,7 @@
 // Auto-generated via `yarn polkadot-types-from-defs`, do not edit
 /* eslint-disable */
 
-import type { CumulusPalletDmpQueueCall, CumulusPalletDmpQueueConfigData, CumulusPalletDmpQueueError, CumulusPalletDmpQueueEvent, CumulusPalletDmpQueuePageIndexData, CumulusPalletParachainSystemCall, CumulusPalletParachainSystemError, CumulusPalletParachainSystemEvent, CumulusPalletParachainSystemRelayStateSnapshotMessagingStateSnapshot, CumulusPalletXcmCall, CumulusPalletXcmError, CumulusPalletXcmEvent, CumulusPalletXcmpQueueCall, CumulusPalletXcmpQueueError, CumulusPalletXcmpQueueEvent, CumulusPalletXcmpQueueInboundChannelDetails, CumulusPalletXcmpQueueInboundState, CumulusPalletXcmpQueueOutboundChannelDetails, CumulusPalletXcmpQueueOutboundState, CumulusPalletXcmpQueueQueueConfigData, CumulusPrimitivesParachainInherentParachainInherentData, EthbloomBloom, EthereumBlock, EthereumHeader, EthereumLog, EthereumReceiptEip658ReceiptData, EthereumReceiptReceiptV3, EthereumTransactionAccessListItem, EthereumTransactionEip1559Transaction, EthereumTransactionEip2930Transaction, EthereumTransactionLegacyTransaction, EthereumTransactionTransactionAction, EthereumTransactionTransactionSignature, EthereumTransactionTransactionV2, EthereumTypesHashH64, EvmCoreErrorExitError, EvmCoreErrorExitFatal, EvmCoreErrorExitReason, EvmCoreErrorExitRevert, EvmCoreErrorExitSucceed, FpRpcTransactionStatus, FrameSupportPalletId, FrameSupportTokensMiscBalanceStatus, FrameSupportWeightsDispatchClass, FrameSupportWeightsDispatchInfo, FrameSupportWeightsPays, FrameSupportWeightsPerDispatchClassU32, FrameSupportWeightsPerDispatchClassU64, FrameSupportWeightsPerDispatchClassWeightsPerClass, FrameSupportWeightsRuntimeDbWeight, FrameSupportWeightsWeightToFeeCoefficient, FrameSystemAccountInfo, FrameSystemCall, FrameSystemError, FrameSystemEvent, FrameSystemEventRecord, FrameSystemExtensionsCheckGenesis, FrameSystemExtensionsCheckNonce, FrameSystemExtensionsCheckSpecVersion, FrameSystemExtensionsCheckWeight, FrameSystemLastRuntimeUpgradeInfo, FrameSystemLimitsBlockLength, FrameSystemLimitsBlockWeights, FrameSystemLimitsWeightsPerClass, FrameSystemPhase, OrmlVestingModuleCall, OrmlVestingModuleError, OrmlVestingModuleEvent, OrmlVestingVestingSchedule, PalletBalancesAccountData, PalletBalancesBalanceLock, PalletBalancesCall, PalletBalancesError, PalletBalancesEvent, PalletBalancesReasons, PalletBalancesReleases, PalletBalancesReserveData, PalletCommonAccountBasicCrossAccountIdRepr, PalletCommonError, PalletCommonEvent, PalletEthereumCall, PalletEthereumError, PalletEthereumEvent, PalletEvmCall, PalletEvmCoderSubstrateError, PalletEvmContractHelpersError, PalletEvmContractHelpersSponsoringModeT, PalletEvmError, PalletEvmEvent, PalletEvmMigrationCall, PalletEvmMigrationError, PalletFungibleError, PalletInflationCall, PalletNonfungibleError, PalletNonfungibleItemData, PalletRefungibleError, PalletRefungibleItemData, PalletSudoCall, PalletSudoError, PalletSudoEvent, PalletTemplateTransactionPaymentCall, PalletTemplateTransactionPaymentChargeTransactionPayment, PalletTimestampCall, PalletTransactionPaymentReleases, PalletTreasuryCall, PalletTreasuryError, PalletTreasuryEvent, PalletTreasuryProposal, PalletUniqueCall, PalletUniqueError, PalletUniqueRawEvent, PalletXcmCall, PalletXcmError, PalletXcmEvent, PolkadotCorePrimitivesInboundDownwardMessage, PolkadotCorePrimitivesInboundHrmpMessage, PolkadotCorePrimitivesOutboundHrmpMessage, PolkadotParachainPrimitivesXcmpMessageFormat, PolkadotPrimitivesV1AbridgedHostConfiguration, PolkadotPrimitivesV1AbridgedHrmpChannel, PolkadotPrimitivesV1PersistedValidationData, PolkadotPrimitivesV1UpgradeRestriction, SpCoreEcdsaSignature, SpCoreEd25519Signature, SpCoreSr25519Signature, SpRuntimeArithmeticError, SpRuntimeDigest, SpRuntimeDigestDigestItem, SpRuntimeDispatchError, SpRuntimeMultiSignature, SpRuntimeTokenError, SpTrieStorageProof, SpVersionRuntimeVersion, UniqueRuntimeRuntime, UpDataStructsAccessMode, UpDataStructsCollection, UpDataStructsCollectionLimits, UpDataStructsCollectionMode, UpDataStructsCollectionStats, UpDataStructsCreateCollectionData, UpDataStructsCreateFungibleData, UpDataStructsCreateItemData, UpDataStructsCreateNftData, UpDataStructsCreateReFungibleData, UpDataStructsMetaUpdatePermission, UpDataStructsSchemaVersion, UpDataStructsSponsorshipState, XcmDoubleEncoded, XcmV0Junction, XcmV0JunctionBodyId, XcmV0JunctionBodyPart, XcmV0JunctionNetworkId, XcmV0MultiAsset, XcmV0MultiLocation, XcmV0Order, XcmV0OriginKind, XcmV0Response, XcmV0Xcm, XcmV1Junction, XcmV1MultiAsset, XcmV1MultiLocation, XcmV1MultiassetAssetId, XcmV1MultiassetAssetInstance, XcmV1MultiassetFungibility, XcmV1MultiassetMultiAssetFilter, XcmV1MultiassetMultiAssets, XcmV1MultiassetWildFungibility, XcmV1MultiassetWildMultiAsset, XcmV1MultilocationJunctions, XcmV1Order, XcmV1Response, XcmV1Xcm, XcmV2Instruction, XcmV2Response, XcmV2TraitsError, XcmV2TraitsOutcome, XcmV2WeightLimit, XcmV2Xcm, XcmVersionedMultiAssets, XcmVersionedMultiLocation, XcmVersionedXcm } from './unique';
+import type { CumulusPalletDmpQueueCall, CumulusPalletDmpQueueConfigData, CumulusPalletDmpQueueError, CumulusPalletDmpQueueEvent, CumulusPalletDmpQueuePageIndexData, CumulusPalletParachainSystemCall, CumulusPalletParachainSystemError, CumulusPalletParachainSystemEvent, CumulusPalletParachainSystemRelayStateSnapshotMessagingStateSnapshot, CumulusPalletXcmCall, CumulusPalletXcmError, CumulusPalletXcmEvent, CumulusPalletXcmpQueueCall, CumulusPalletXcmpQueueError, CumulusPalletXcmpQueueEvent, CumulusPalletXcmpQueueInboundChannelDetails, CumulusPalletXcmpQueueInboundState, CumulusPalletXcmpQueueOutboundChannelDetails, CumulusPalletXcmpQueueOutboundState, CumulusPalletXcmpQueueQueueConfigData, CumulusPrimitivesParachainInherentParachainInherentData, EthbloomBloom, EthereumBlock, EthereumHeader, EthereumLog, EthereumReceiptEip658ReceiptData, EthereumReceiptReceiptV3, EthereumTransactionAccessListItem, EthereumTransactionEip1559Transaction, EthereumTransactionEip2930Transaction, EthereumTransactionLegacyTransaction, EthereumTransactionTransactionAction, EthereumTransactionTransactionSignature, EthereumTransactionTransactionV2, EthereumTypesHashH64, EvmCoreErrorExitError, EvmCoreErrorExitFatal, EvmCoreErrorExitReason, EvmCoreErrorExitRevert, EvmCoreErrorExitSucceed, FpRpcTransactionStatus, FrameSupportPalletId, FrameSupportTokensMiscBalanceStatus, FrameSupportWeightsDispatchClass, FrameSupportWeightsDispatchInfo, FrameSupportWeightsPays, FrameSupportWeightsPerDispatchClassU32, FrameSupportWeightsPerDispatchClassU64, FrameSupportWeightsPerDispatchClassWeightsPerClass, FrameSupportWeightsRuntimeDbWeight, FrameSupportWeightsWeightToFeeCoefficient, FrameSystemAccountInfo, FrameSystemCall, FrameSystemError, FrameSystemEvent, FrameSystemEventRecord, FrameSystemExtensionsCheckGenesis, FrameSystemExtensionsCheckNonce, FrameSystemExtensionsCheckSpecVersion, FrameSystemExtensionsCheckWeight, FrameSystemLastRuntimeUpgradeInfo, FrameSystemLimitsBlockLength, FrameSystemLimitsBlockWeights, FrameSystemLimitsWeightsPerClass, FrameSystemPhase, OrmlVestingModuleCall, OrmlVestingModuleError, OrmlVestingModuleEvent, OrmlVestingVestingSchedule, PalletBalancesAccountData, PalletBalancesBalanceLock, PalletBalancesCall, PalletBalancesError, PalletBalancesEvent, PalletBalancesReasons, PalletBalancesReleases, PalletBalancesReserveData, PalletCommonAccountBasicCrossAccountIdRepr, PalletCommonError, PalletCommonEvent, PalletEthereumCall, PalletEthereumError, PalletEthereumEvent, PalletEvmCall, PalletEvmCoderSubstrateError, PalletEvmContractHelpersError, PalletEvmContractHelpersSponsoringModeT, PalletEvmError, PalletEvmEvent, PalletEvmMigrationCall, PalletEvmMigrationError, PalletFungibleError, PalletInflationCall, PalletNonfungibleError, PalletNonfungibleItemData, PalletRefungibleError, PalletRefungibleItemData, PalletSudoCall, PalletSudoError, PalletSudoEvent, PalletTemplateTransactionPaymentCall, PalletTemplateTransactionPaymentChargeTransactionPayment, PalletTimestampCall, PalletTransactionPaymentReleases, PalletTreasuryCall, PalletTreasuryError, PalletTreasuryEvent, PalletTreasuryProposal, PalletUniqueCall, PalletUniqueError, PalletUniqueRawEvent, PalletXcmCall, PalletXcmError, PalletXcmEvent, PolkadotCorePrimitivesInboundDownwardMessage, PolkadotCorePrimitivesInboundHrmpMessage, PolkadotCorePrimitivesOutboundHrmpMessage, PolkadotParachainPrimitivesXcmpMessageFormat, PolkadotPrimitivesV1AbridgedHostConfiguration, PolkadotPrimitivesV1AbridgedHrmpChannel, PolkadotPrimitivesV1PersistedValidationData, PolkadotPrimitivesV1UpgradeRestriction, SpCoreEcdsaSignature, SpCoreEd25519Signature, SpCoreSr25519Signature, SpRuntimeArithmeticError, SpRuntimeDigest, SpRuntimeDigestDigestItem, SpRuntimeDispatchError, SpRuntimeMultiSignature, SpRuntimeTokenError, SpTrieStorageProof, SpVersionRuntimeVersion, UniqueRuntimeRuntime, UpDataStructsAccessMode, UpDataStructsCollection, UpDataStructsCollectionLimits, UpDataStructsCollectionMode, UpDataStructsCollectionStats, UpDataStructsCreateCollectionData, UpDataStructsCreateFungibleData, UpDataStructsCreateItemData, UpDataStructsCreateNftData, UpDataStructsCreateReFungibleData, UpDataStructsMetaUpdatePermission, UpDataStructsSchemaVersion, UpDataStructsSponsoringRateLimit, UpDataStructsSponsorshipState, XcmDoubleEncoded, XcmV0Junction, XcmV0JunctionBodyId, XcmV0JunctionBodyPart, XcmV0JunctionNetworkId, XcmV0MultiAsset, XcmV0MultiLocation, XcmV0Order, XcmV0OriginKind, XcmV0Response, XcmV0Xcm, XcmV1Junction, XcmV1MultiAsset, XcmV1MultiLocation, XcmV1MultiassetAssetId, XcmV1MultiassetAssetInstance, XcmV1MultiassetFungibility, XcmV1MultiassetMultiAssetFilter, XcmV1MultiassetMultiAssets, XcmV1MultiassetWildFungibility, XcmV1MultiassetWildMultiAsset, XcmV1MultilocationJunctions, XcmV1Order, XcmV1Response, XcmV1Xcm, XcmV2Instruction, XcmV2Response, XcmV2TraitsError, XcmV2TraitsOutcome, XcmV2WeightLimit, XcmV2Xcm, XcmVersionedMultiAssets, XcmVersionedMultiLocation, XcmVersionedXcm } from './unique';
 import type { Data, StorageKey } from '@polkadot/types';
 import type { BitVec, Bool, Bytes, I128, I16, I256, I32, I64, I8, Json, Null, Raw, Text, Type, U128, U16, U256, U32, U64, U8, USize, bool, i128, i16, i256, i32, i64, i8, u128, u16, u256, u32, u64, u8, usize } from '@polkadot/types-codec';
 import type { AssetApproval, AssetApprovalKey, AssetBalance, AssetDestroyWitness, AssetDetails, AssetMetadata, TAssetBalance, TAssetDepositBalance } from '@polkadot/types/interfaces/assets';
@@ -1167,6 +1167,7 @@
     UpDataStructsCreateReFungibleData: UpDataStructsCreateReFungibleData;
     UpDataStructsMetaUpdatePermission: UpDataStructsMetaUpdatePermission;
     UpDataStructsSchemaVersion: UpDataStructsSchemaVersion;
+    UpDataStructsSponsoringRateLimit: UpDataStructsSponsoringRateLimit;
     UpDataStructsSponsorshipState: UpDataStructsSponsorshipState;
     UpgradeGoAhead: UpgradeGoAhead;
     UpgradeRestriction: UpgradeRestriction;
modifiedtests/src/interfaces/types-lookup.tsdiffbeforeafterboth
--- a/tests/src/interfaces/types-lookup.ts
+++ b/tests/src/interfaces/types-lookup.ts
@@ -1513,11 +1513,19 @@
     readonly type: 'ImageURL' | 'Unique';
   }
 
+  /** @name UpDataStructsSponsoringRateLimit */
+  export interface UpDataStructsSponsoringRateLimit extends Enum {
+    readonly isSponsoringDisabled: boolean;
+    readonly isBlocks: boolean;
+    readonly asBlocks: u32;
+    readonly type: 'SponsoringDisabled' | 'Blocks';
+  }
+
   /** @name UpDataStructsCollectionLimits (163) */
   export interface UpDataStructsCollectionLimits extends Struct {
     readonly accountTokenOwnershipLimit: Option<u32>;
     readonly sponsoredDataSize: Option<u32>;
-    readonly sponsoredDataRateLimit: Option<Option<u32>>;
+    readonly sponsoredDataRateLimit: Option<UpDataStructsSponsoringRateLimit>;
     readonly tokenLimit: Option<u32>;
     readonly sponsorTransferTimeout: Option<u32>;
     readonly sponsorApproveTimeout: Option<u32>;
modifiedtests/src/interfaces/unique/types.tsdiffbeforeafterboth
--- a/tests/src/interfaces/unique/types.ts
+++ b/tests/src/interfaces/unique/types.ts
@@ -1720,7 +1720,7 @@
 export interface UpDataStructsCollectionLimits extends Struct {
   readonly accountTokenOwnershipLimit: Option<u32>;
   readonly sponsoredDataSize: Option<u32>;
-  readonly sponsoredDataRateLimit: Option<Option<u32>>;
+  readonly sponsoredDataRateLimit: Option<UpDataStructsSponsoringRateLimit>;
   readonly tokenLimit: Option<u32>;
   readonly sponsorTransferTimeout: Option<u32>;
   readonly sponsorApproveTimeout: Option<u32>;
@@ -1805,6 +1805,13 @@
   readonly type: 'ImageURL' | 'Unique';
 }
 
+/** @name UpDataStructsSponsoringRateLimit */
+export interface UpDataStructsSponsoringRateLimit extends Enum {
+  readonly isSponsoringDisabled: boolean;
+  readonly isBlocks: boolean;
+  readonly asBlocks: u32;
+}
+
 /** @name UpDataStructsSponsorshipState */
 export interface UpDataStructsSponsorshipState extends Enum {
   readonly isDisabled: boolean;
modifiedtests/src/setVariableMetadataSponsoringRateLimit.test.tsdiffbeforeafterboth
--- a/tests/src/setVariableMetadataSponsoringRateLimit.test.ts
+++ b/tests/src/setVariableMetadataSponsoringRateLimit.test.ts
@@ -4,6 +4,7 @@
 //
 
 import {IKeyringPair} from '@polkadot/types/types';
+import {expect} from 'chai';
 import privateKey from './substrate/privateKey';
 import usingApi from './substrate/substrate-api';
 import {
@@ -11,6 +12,7 @@
   createCollectionExpectSuccess,
   createItemExpectSuccess,
   findUnusedAddress,
+  getDetailedCollectionInfo,
   setCollectionLimitsExpectSuccess,
   setCollectionSponsorExpectSuccess,
   setVariableMetaDataExpectFailure,
@@ -33,7 +35,7 @@
     await setCollectionSponsorExpectSuccess(collectionId, alice.address);
     await confirmSponsorshipExpectSuccess(collectionId);
     await setCollectionLimitsExpectSuccess(alice, collectionId, {
-      sponsoredDataRateLimit: 0,
+      sponsoredDataRateLimit: {Blocks: 0},
     });
 
     const itemId = await createItemExpectSuccess(alice, collectionId, 'NFT', userWithNoBalance.address);
@@ -46,7 +48,7 @@
     await setCollectionSponsorExpectSuccess(collectionId, alice.address);
     await confirmSponsorshipExpectSuccess(collectionId);
     await setCollectionLimitsExpectSuccess(alice, collectionId, {
-      sponsoredDataRateLimit: 10,
+      sponsoredDataRateLimit: {Blocks: 10},
     });
 
     const itemId = await createItemExpectSuccess(alice, collectionId, 'NFT', userWithNoBalance.address);
@@ -59,7 +61,7 @@
     await setCollectionSponsorExpectSuccess(collectionId, alice.address);
     await confirmSponsorshipExpectSuccess(collectionId);
     await setCollectionLimitsExpectSuccess(alice, collectionId, {
-      sponsoredDataRateLimit: 0,
+      sponsoredDataRateLimit: {Blocks: 0},
       sponsoredDataSize: 1,
     });
     const itemId = await createItemExpectSuccess(alice, collectionId, 'NFT', userWithNoBalance.address);
@@ -77,4 +79,32 @@
     await setVariableMetaDataExpectFailure(userWithNoBalance, collectionId, itemId, [1]);
   });
 
+  it('sponsoring of data is disabled by default', async () => {
+    await usingApi(async api => {
+      const collectionId = await createCollectionExpectSuccess();
+
+      const collection = (await getDetailedCollectionInfo(api, collectionId))!;
+      // limit is none = default is used
+      expect(collection?.limits.sponsoredDataRateLimit.isNone);
+    });
+  });
+
+  it('sponsoring can be disabled explicitly', async () => {
+    await usingApi(async api => {
+      const collectionId = await createCollectionExpectSuccess();
+
+      await setCollectionLimitsExpectSuccess(alice, collectionId, {sponsoredDataRateLimit: {Blocks: 6}});
+      {
+        const collection = (await getDetailedCollectionInfo(api, collectionId))!;
+        expect(collection?.limits.sponsoredDataRateLimit.unwrap().asBlocks.toNumber()).to.equal(6);
+      }
+
+      await setCollectionLimitsExpectSuccess(alice, collectionId, {sponsoredDataRateLimit: 'SponsoringDisabled'});
+      {
+        const collection = (await getDetailedCollectionInfo(api, collectionId))!;
+        // disabled sponsoring = default value
+        expect(collection?.limits.sponsoredDataRateLimit.unwrap().isNone).to.true;
+      }
+    });
+  });
 });