git.delta.rocks / unique-network / refs/commits / 836070f4956b

difftreelog

Limits logic fixed. Tests added

str-mv2021-09-08parent: #abfdac1.patch.diff
in: master

4 files changed

modifiedpallets/nft/src/lib.rsdiffbeforeafterboth
--- a/pallets/nft/src/lib.rs
+++ b/pallets/nft/src/lib.rs
@@ -302,9 +302,6 @@
 		/// Amount of collections destroyed, used for total amount tracking with
 		/// CreatedCollectionCount
 		DestroyedCollectionCount: u32;
-		/// Total amount of account owned tokens (NFTs + RFTs + unique fungibles)
-		/// Account id (real)
-		pub AccountItemCount get(fn account_item_count): map hasher(twox_64_concat) T::AccountId => u32;
 		//#endregion
 
 		//#region Basic collections
@@ -1595,11 +1592,19 @@
 		collection.consume_sload()?;
 		let account_items: u32 =
 			<AddressTokens<T>>::get(collection_id, recipient.as_sub()).len() as u32;
-		ensure!(
-			collection.limits.account_token_ownership_limit > account_items,
-			Error::<T>::AccountTokenLimitExceeded
-		);
 
+		// zero limit means collection limit is disabled
+		// otherwise get lower value
+		let limit = if collection.limits.account_token_ownership_limit == 0
+			|| collection.limits.account_token_ownership_limit > ACCOUNT_TOKEN_OWNERSHIP_LIMIT
+		{
+			ACCOUNT_TOKEN_OWNERSHIP_LIMIT
+		} else {
+			collection.limits.account_token_ownership_limit
+		};
+
+		ensure!(limit > account_items, Error::<T>::AccountTokenLimitExceeded);
+
 		// preliminary transfer check
 		ensure!(collection.transfers_enabled, Error::<T>::TransferNotAllowed);
 
@@ -1622,12 +1627,23 @@
 			as u32)
 			.checked_add(amount)
 			.ok_or(Error::<T>::AccountTokenLimitExceeded)?;
+
+		// zero limit means collection limit is disabled
+		// otherwise get lower value
+		let account_token_limit = if collection.limits.account_token_ownership_limit == 0
+			|| collection.limits.account_token_ownership_limit > ACCOUNT_TOKEN_OWNERSHIP_LIMIT
+		{
+			ACCOUNT_TOKEN_OWNERSHIP_LIMIT
+		} else {
+			collection.limits.account_token_ownership_limit
+		};
+
 		ensure!(
 			collection.limits.token_limit >= total_items,
 			Error::<T>::CollectionTokenLimitExceeded
 		);
 		ensure!(
-			collection.limits.account_token_ownership_limit >= account_items,
+			account_token_limit >= account_items,
 			Error::<T>::AccountTokenLimitExceeded
 		);
 
@@ -2362,32 +2378,19 @@
 		item_index: TokenId,
 		owner: &T::CrossAccountId,
 	) -> DispatchResult {
-		// add to account limit
 		collection.consume_sload()?;
-		if <AccountItemCount<T>>::contains_key(owner.as_sub()) {
-			// bound Owned tokens by a single address
+		let list_exists = <AddressTokens<T>>::contains_key(collection.id, owner.as_sub());
+		if list_exists {
 			collection.consume_sload()?;
-			let count = <AccountItemCount<T>>::get(owner.as_sub());
+			let mut list = <AddressTokens<T>>::get(collection.id, owner.as_sub());
+
+			// bound Owned tokens by a single address in collection
+			let account_items: u32 = list.len() as u32;
 			ensure!(
-				count < ACCOUNT_TOKEN_OWNERSHIP_LIMIT,
+				account_items < ACCOUNT_TOKEN_OWNERSHIP_LIMIT,
 				Error::<T>::AddressOwnershipLimitExceeded
 			);
-
-			collection.consume_sstore()?;
-			<AccountItemCount<T>>::insert(
-				owner.as_sub(),
-				count.checked_add(1).ok_or(Error::<T>::NumOverflow)?,
-			);
-		} else {
-			collection.consume_sstore()?;
-			<AccountItemCount<T>>::insert(owner.as_sub(), 1);
-		}
 
-		collection.consume_sload()?;
-		let list_exists = <AddressTokens<T>>::contains_key(collection.id, owner.as_sub());
-		if list_exists {
-			collection.consume_sload()?;
-			let mut list = <AddressTokens<T>>::get(collection.id, owner.as_sub());
 			let item_contains = list.contains(&item_index.clone());
 
 			if !item_contains {
@@ -2410,16 +2413,6 @@
 		item_index: TokenId,
 		owner: &T::CrossAccountId,
 	) -> DispatchResult {
-		// update counter
-		collection.consume_sload()?;
-		collection.consume_sstore()?;
-		<AccountItemCount<T>>::insert(
-			owner.as_sub(),
-			<AccountItemCount<T>>::get(owner.as_sub())
-				.checked_sub(1)
-				.ok_or(Error::<T>::NumOverflow)?,
-		);
-
 		collection.consume_sload()?;
 		let list_exists = <AddressTokens<T>>::contains_key(collection.id, owner.as_sub());
 		if list_exists {
modifiedpallets/nft/src/sponsorship.rsdiffbeforeafterboth
61			sponsor_transfer = match collection_mode {61			sponsor_transfer = match collection_mode {
62				CollectionMode::NFT => {62				CollectionMode::NFT => {
63					// get correct limit63					// get correct limit
64					let limit: u32 = if collection_limits.sponsor_transfer_timeout > 0 {64					let limit: u32 = if collection_limits.sponsor_transfer_timeout != 0 {
65						if collection_limits.sponsor_transfer_timeout > NFT_SPONSOR_TRANSFER_TIMEOUT
66						{
65						collection_limits.sponsor_transfer_timeout67							collection_limits.sponsor_transfer_timeout
66					} else {68						} else {
67						NFT_SPONSOR_TRANSFER_TIMEOUT69							NFT_SPONSOR_TRANSFER_TIMEOUT
68					};70						}
71					} else {
72						0
73					};
6974
70					let mut sponsored = true;75					let mut sponsored = true;
71					if NftTransferBasket::<T>::contains_key(collection_id, item_id) {76					if NftTransferBasket::<T>::contains_key(collection_id, item_id) {
83				}88				}
84				CollectionMode::Fungible(_) => {89				CollectionMode::Fungible(_) => {
85					// get correct limit90					// get correct limit
86					let limit: u32 = if collection_limits.sponsor_transfer_timeout > 0 {91					let limit: u32 = if collection_limits.sponsor_transfer_timeout != 0 {
92						if collection_limits.sponsor_transfer_timeout
93							> FUNGIBLE_SPONSOR_TRANSFER_TIMEOUT
94						{
87						collection_limits.sponsor_transfer_timeout95							collection_limits.sponsor_transfer_timeout
88					} else {96						} else {
89						FUNGIBLE_SPONSOR_TRANSFER_TIMEOUT97							FUNGIBLE_SPONSOR_TRANSFER_TIMEOUT
90					};98						}
9199					} else {
92					let block_number = <frame_system::Pallet<T>>::block_number() as T::BlockNumber;100						0
101					};
102
93					let mut sponsored = true;103					let mut sponsored = true;
94					if FungibleTransferBasket::<T>::contains_key(collection_id, who) {104					if FungibleTransferBasket::<T>::contains_key(collection_id, who) {
106				}116				}
107				CollectionMode::ReFungible => {117				CollectionMode::ReFungible => {
108					// get correct limit118					// get correct limit
109					let limit: u32 = if collection_limits.sponsor_transfer_timeout > 0 {119					let limit: u32 = if collection_limits.sponsor_transfer_timeout != 0 {
120						if collection_limits.sponsor_transfer_timeout
121							> REFUNGIBLE_SPONSOR_TRANSFER_TIMEOUT
122						{
110						collection_limits.sponsor_transfer_timeout123							collection_limits.sponsor_transfer_timeout
111					} else {124						} else {
112						REFUNGIBLE_SPONSOR_TRANSFER_TIMEOUT125							REFUNGIBLE_SPONSOR_TRANSFER_TIMEOUT
113					};126						}
127					} else {
128						0
129					};
114130
115					let mut sponsored = true;131					let mut sponsored = true;
116					if ReFungibleTransferBasket::<T>::contains_key(collection_id, item_id) {132					if ReFungibleTransferBasket::<T>::contains_key(collection_id, item_id) {
addedtests/src/limits.test.tsdiffbeforeafterboth
--- /dev/null
+++ b/tests/src/limits.test.ts
@@ -0,0 +1,378 @@
+//
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE', which is part of this source code package.
+//
+
+import { IKeyringPair } from '@polkadot/types/types';
+import privateKey from './substrate/privateKey';
+import usingApi from './substrate/substrate-api';
+import {
+  createCollectionExpectSuccess,
+  destroyCollectionExpectSuccess,
+  setCollectionLimitsExpectSuccess,
+  setCollectionSponsorExpectSuccess,
+  confirmSponsorshipExpectSuccess,
+  createItemExpectSuccess,
+  createItemExpectFailure,
+  transferExpectSuccess,
+  getFreeBalance,
+  waitNewBlocks,
+} from './util/helpers'; 
+import { expect } from 'chai';
+
+describe('Number of tokens per address (NFT)', () => {
+  let Alice: IKeyringPair;
+
+  before(async () => {
+    await usingApi(async () => {
+      Alice = privateKey('//Alice');
+    });
+  });
+
+  it('Collection limits allow greater number than chain limits, chain limits are enforced', async () => {
+      
+    const collectionId = await createCollectionExpectSuccess({ mode: { type: 'NFT' } });
+    await setCollectionLimitsExpectSuccess(Alice, collectionId, { AccountTokenOwnershipLimit: 20 });
+    for(let i = 0; i < 10; i++){
+      await createItemExpectSuccess(Alice, collectionId, 'NFT');
+    }
+    await createItemExpectFailure(Alice, collectionId, 'NFT');
+    await destroyCollectionExpectSuccess(collectionId);
+  });
+
+  it('Collection limits allow lower number than chain limits, collection limits are enforced', async () => {
+
+    const collectionId = await createCollectionExpectSuccess({ mode: { type: 'NFT' } });
+    await setCollectionLimitsExpectSuccess(Alice, collectionId, { AccountTokenOwnershipLimit: 1 });
+    await createItemExpectSuccess(Alice, collectionId, 'NFT');
+    await createItemExpectFailure(Alice, collectionId, 'NFT');
+    await destroyCollectionExpectSuccess(collectionId);
+  });
+});
+
+describe('Number of tokens per address (ReFungible)', () => {
+  let Alice: IKeyringPair;
+
+  before(async () => {
+    await usingApi(async () => {
+      Alice = privateKey('//Alice');
+    });
+  });
+
+  it('Collection limits allow greater number than chain limits, chain limits are enforced', async () => {   
+    const collectionId = await createCollectionExpectSuccess({mode: {type: 'ReFungible' }});
+    await setCollectionLimitsExpectSuccess(Alice, collectionId, { AccountTokenOwnershipLimit: 20 });
+    for(let i = 0; i < 10; i++){
+      await createItemExpectSuccess(Alice, collectionId, 'ReFungible');
+    }
+    await createItemExpectFailure(Alice, collectionId, 'ReFungible');
+    await destroyCollectionExpectSuccess(collectionId);
+  });
+
+  it('Collection limits allow lower number than chain limits, collection limits are enforced', async () => {
+    const collectionId = await createCollectionExpectSuccess({mode: {type: 'ReFungible' }});
+    await setCollectionLimitsExpectSuccess(Alice, collectionId, { AccountTokenOwnershipLimit: 1 });
+    await createItemExpectSuccess(Alice, collectionId, 'ReFungible');
+    await createItemExpectFailure(Alice, collectionId, 'ReFungible');
+    await destroyCollectionExpectSuccess(collectionId);
+  });
+});
+
+describe('Sponsor timeout (NFT)', () => {
+  let Alice: IKeyringPair;
+  let Bob: IKeyringPair;
+  let Charlie: IKeyringPair;
+
+  before(async () => {
+    await usingApi(async () => {
+      Alice = privateKey('//Alice');
+      Bob = privateKey('//Bob');
+      Charlie = privateKey('//Charlie');
+    });
+  });
+
+  it('Collection limits have greater timeout value than chain limits, collection limits are enforced', async () => {  
+    const collectionId = await createCollectionExpectSuccess({ mode: { type: 'NFT' } });
+    await setCollectionLimitsExpectSuccess(Alice, collectionId, { SponsorTimeout: 7 });
+    const tokenId = await createItemExpectSuccess(Alice, collectionId, 'NFT');
+    await setCollectionSponsorExpectSuccess(collectionId, Alice.address);
+    await confirmSponsorshipExpectSuccess(collectionId, '//Alice');
+    await transferExpectSuccess(collectionId, tokenId, Alice, Bob);
+    const aliceBalanceBefore = (await getFreeBalance(Alice)).toNumber();
+
+    // check setting SponsorTimeout = 5, fail
+    await waitNewBlocks(5);
+    await transferExpectSuccess(collectionId, tokenId, Bob, Charlie);
+    const aliceBalanceAfterUnsponsoredTransaction = (await getFreeBalance(Alice)).toNumber();
+    expect(aliceBalanceAfterUnsponsoredTransaction).to.be.equals(aliceBalanceBefore);
+
+    // check setting SponsorTimeout = 7, success
+    await waitNewBlocks(2); // 5 + 2
+    await transferExpectSuccess(collectionId, tokenId, Charlie, Bob);
+    const aliceBalanceAfterSponsoredTransaction = (await getFreeBalance(Alice)).toNumber();
+    expect(aliceBalanceAfterSponsoredTransaction).to.be.lessThan(aliceBalanceBefore);
+    await destroyCollectionExpectSuccess(collectionId);
+  });
+
+  it('Collection limits have lower timeout value than chain limits, chain limits are enforced', async () => {
+
+    const collectionId = await createCollectionExpectSuccess({ mode: { type: 'NFT' } });
+    await setCollectionLimitsExpectSuccess(Alice, collectionId, { SponsorTimeout: 1 });
+    const tokenId = await createItemExpectSuccess(Alice, collectionId, 'NFT');
+    await setCollectionSponsorExpectSuccess(collectionId, Alice.address);
+    await confirmSponsorshipExpectSuccess(collectionId, '//Alice');
+    await transferExpectSuccess(collectionId, tokenId, Alice, Bob);
+    const aliceBalanceBefore = (await getFreeBalance(Alice)).toNumber();
+
+    // check setting SponsorTimeout = 1, fail
+    await waitNewBlocks(1);
+    await transferExpectSuccess(collectionId, tokenId, Bob, Charlie);
+    const aliceBalanceAfterUnsponsoredTransaction = (await getFreeBalance(Alice)).toNumber();
+    expect(aliceBalanceAfterUnsponsoredTransaction).to.be.equals(aliceBalanceBefore);
+
+    // check setting SponsorTimeout = 5, success
+    await waitNewBlocks(4);
+    await transferExpectSuccess(collectionId, tokenId, Charlie, Bob);
+    const aliceBalanceAfterSponsoredTransaction = (await getFreeBalance(Alice)).toNumber();
+    expect(aliceBalanceAfterSponsoredTransaction).to.be.lessThan(aliceBalanceBefore);
+    await destroyCollectionExpectSuccess(collectionId);
+  });
+});
+
+describe('Sponsor timeout (Fungible)', () => {
+  let Alice: IKeyringPair;
+  let Bob: IKeyringPair;
+  let Charlie: IKeyringPair;
+
+  before(async () => {
+    await usingApi(async () => {
+      Alice = privateKey('//Alice');
+      Bob = privateKey('//Bob');
+      Charlie = privateKey('//Charlie');
+    });
+  });
+
+  it('Collection limits have greater timeout value than chain limits, collection limits are enforced', async () => {  
+    const collectionId = await createCollectionExpectSuccess({mode: {type: 'Fungible', decimalPoints: 0}});
+    await setCollectionLimitsExpectSuccess(Alice, collectionId, { SponsorTimeout: 7 });
+    const tokenId = await createItemExpectSuccess(Alice, collectionId, 'Fungible');
+    await setCollectionSponsorExpectSuccess(collectionId, Alice.address);
+    await confirmSponsorshipExpectSuccess(collectionId, '//Alice');
+    await transferExpectSuccess(collectionId, tokenId, Alice, Bob, 10, 'Fungible');
+    await transferExpectSuccess(collectionId, tokenId, Bob, Charlie, 2, 'Fungible');
+    const aliceBalanceBefore = (await getFreeBalance(Alice)).toNumber();
+
+    // check setting SponsorTimeout = 5, fail
+    await waitNewBlocks(5);
+    await transferExpectSuccess(collectionId, tokenId, Bob, Charlie, 2, 'Fungible');
+    const aliceBalanceAfterUnsponsoredTransaction = (await getFreeBalance(Alice)).toNumber();
+    expect(aliceBalanceAfterUnsponsoredTransaction).to.be.equals(aliceBalanceBefore);
+
+    // check setting SponsorTimeout = 7, success
+    await waitNewBlocks(2); // 5 + 2
+    await transferExpectSuccess(collectionId, tokenId, Bob, Charlie, 2, 'Fungible');
+    const aliceBalanceAfterSponsoredTransaction = (await getFreeBalance(Alice)).toNumber();
+    expect(aliceBalanceAfterSponsoredTransaction).to.be.lessThan(aliceBalanceBefore);
+
+    await destroyCollectionExpectSuccess(collectionId);
+  });
+
+  it('Collection limits have lower timeout value than chain limits, chain limits are enforced', async () => {
+
+    const collectionId = await createCollectionExpectSuccess({mode: {type: 'Fungible', decimalPoints: 0}});
+    await setCollectionLimitsExpectSuccess(Alice, collectionId, { SponsorTimeout: 1 });
+    const tokenId = await createItemExpectSuccess(Alice, collectionId, 'Fungible');
+    await setCollectionSponsorExpectSuccess(collectionId, Alice.address);
+    await confirmSponsorshipExpectSuccess(collectionId, '//Alice');
+    await transferExpectSuccess(collectionId, tokenId, Alice, Bob, 10, 'Fungible');
+    await transferExpectSuccess(collectionId, tokenId, Bob, Charlie, 2, 'Fungible');
+    const aliceBalanceBefore = (await getFreeBalance(Alice)).toNumber();
+
+    // check setting SponsorTimeout = 1, fail
+    await waitNewBlocks(1);
+    await transferExpectSuccess(collectionId, tokenId, Bob, Charlie, 2, 'Fungible');
+    const aliceBalanceAfterUnsponsoredTransaction = (await getFreeBalance(Alice)).toNumber();
+    expect(aliceBalanceAfterUnsponsoredTransaction).to.be.equals(aliceBalanceBefore);
+
+    // check setting SponsorTimeout = 5, success
+    await waitNewBlocks(4);
+    await transferExpectSuccess(collectionId, tokenId, Bob, Charlie, 2, 'Fungible');
+    const aliceBalanceAfterSponsoredTransaction = (await getFreeBalance(Alice)).toNumber();
+    expect(aliceBalanceAfterSponsoredTransaction).to.be.lessThan(aliceBalanceBefore);
+
+    await destroyCollectionExpectSuccess(collectionId);
+  });
+});
+
+describe('Sponsor timeout (ReFungible)', () => {
+  let Alice: IKeyringPair;
+  let Bob: IKeyringPair;
+  let Charlie: IKeyringPair;
+
+  before(async () => {
+    await usingApi(async () => {
+      Alice = privateKey('//Alice');
+      Bob = privateKey('//Bob');
+      Charlie = privateKey('//Charlie');
+    });
+  });
+
+  it('Collection limits have greater timeout value than chain limits, collection limits are enforced', async () => {  
+    const collectionId = await createCollectionExpectSuccess({mode: {type: 'ReFungible' }});
+    await setCollectionLimitsExpectSuccess(Alice, collectionId, { SponsorTimeout: 7 });
+    const tokenId = await createItemExpectSuccess(Alice, collectionId, 'ReFungible');
+    await setCollectionSponsorExpectSuccess(collectionId, Alice.address);
+    await confirmSponsorshipExpectSuccess(collectionId, '//Alice');
+    await transferExpectSuccess(collectionId, tokenId, Alice, Bob, 100, 'ReFungible');
+    const aliceBalanceBefore = (await getFreeBalance(Alice)).toNumber();
+
+    // check setting SponsorTimeout = 5, fail
+    await waitNewBlocks(5);
+    await transferExpectSuccess(collectionId, tokenId, Bob, Charlie, 20, 'ReFungible');
+    const aliceBalanceAfterUnsponsoredTransaction = (await getFreeBalance(Alice)).toNumber();
+    expect(aliceBalanceAfterUnsponsoredTransaction).to.be.equals(aliceBalanceBefore);
+
+    // check setting SponsorTimeout = 7, success
+    await waitNewBlocks(2); // 5 + 2
+    await transferExpectSuccess(collectionId, tokenId, Bob, Charlie, 20, 'ReFungible');
+    const aliceBalanceAfterSponsoredTransaction = (await getFreeBalance(Alice)).toNumber();
+    expect(aliceBalanceAfterSponsoredTransaction).to.be.lessThan(aliceBalanceBefore);
+    await destroyCollectionExpectSuccess(collectionId);
+  });
+
+  it('Collection limits have lower timeout value than chain limits, chain limits are enforced', async () => {
+
+    const collectionId = await createCollectionExpectSuccess({ mode: { type: 'NFT' } });
+    await setCollectionLimitsExpectSuccess(Alice, collectionId, { SponsorTimeout: 1 });
+    const tokenId = await createItemExpectSuccess(Alice, collectionId, 'NFT');
+    await setCollectionSponsorExpectSuccess(collectionId, Alice.address);
+    await confirmSponsorshipExpectSuccess(collectionId, '//Alice');
+    await transferExpectSuccess(collectionId, tokenId, Alice, Bob);
+    const aliceBalanceBefore = (await getFreeBalance(Alice)).toNumber();
+
+    // check setting SponsorTimeout = 1, fail
+    await waitNewBlocks(1);
+    await transferExpectSuccess(collectionId, tokenId, Bob, Charlie);
+    const aliceBalanceAfterUnsponsoredTransaction = (await getFreeBalance(Alice)).toNumber();
+    expect(aliceBalanceAfterUnsponsoredTransaction).to.be.equals(aliceBalanceBefore);
+
+    // check setting SponsorTimeout = 5, success
+    await waitNewBlocks(4);
+    await transferExpectSuccess(collectionId, tokenId, Charlie, Bob);
+    const aliceBalanceAfterSponsoredTransaction = (await getFreeBalance(Alice)).toNumber();
+    expect(aliceBalanceAfterSponsoredTransaction).to.be.lessThan(aliceBalanceBefore);
+    await destroyCollectionExpectSuccess(collectionId);
+  });
+});
+
+describe('Collection zero limits (NFT)', () => {
+  let Alice: IKeyringPair;
+  let Bob: IKeyringPair;
+  let Charlie: IKeyringPair;
+
+  before(async () => {
+    await usingApi(async () => {
+      Alice = privateKey('//Alice');
+      Bob = privateKey('//Bob');
+      Charlie = privateKey('//Charlie');
+    });
+  });
+
+  it('Limits have 0 in tokens per address field, the chain limits are applied', async () => {  
+    const collectionId = await createCollectionExpectSuccess({ mode: { type: 'NFT' } });
+    await setCollectionLimitsExpectSuccess(Alice, collectionId, { AccountTokenOwnershipLimit: 0 });
+    for(let i = 0; i < 10; i++){
+      await createItemExpectSuccess(Alice, collectionId, 'NFT');
+    }
+    await createItemExpectFailure(Alice, collectionId, 'NFT');
+  });
+
+  it('Limits have 0 in sponsor timeout, no limits are applied', async () => {
+
+    const collectionId = await createCollectionExpectSuccess({ mode: { type: 'NFT' } });
+    await setCollectionLimitsExpectSuccess(Alice, collectionId, { SponsorTimeout: 0 });
+    const tokenId = await createItemExpectSuccess(Alice, collectionId, 'NFT');
+    await setCollectionSponsorExpectSuccess(collectionId, Alice.address);
+    await confirmSponsorshipExpectSuccess(collectionId, '//Alice');
+    await transferExpectSuccess(collectionId, tokenId, Alice, Bob);
+    const aliceBalanceBefore = (await getFreeBalance(Alice)).toNumber();
+
+    // check setting SponsorTimeout = 0, success with next block
+    await waitNewBlocks(1);
+    await transferExpectSuccess(collectionId, tokenId, Bob, Charlie);
+    const aliceBalanceAfterSponsoredTransaction1 = (await getFreeBalance(Alice)).toNumber();
+    expect(aliceBalanceAfterSponsoredTransaction1).to.be.lessThan(aliceBalanceBefore);
+  });
+});
+
+describe.only('Collection zero limits (Fungible)', () => {
+  let Alice: IKeyringPair;
+  let Bob: IKeyringPair;
+  let Charlie: IKeyringPair;
+
+  before(async () => {
+    await usingApi(async () => {
+      Alice = privateKey('//Alice');
+      Bob = privateKey('//Bob');
+      Charlie = privateKey('//Charlie');
+    });
+  });
+
+  it('Limits have 0 in sponsor timeout, no limits are applied', async () => {
+    const collectionId = await createCollectionExpectSuccess({mode: {type: 'Fungible', decimalPoints: 0}});
+    await setCollectionLimitsExpectSuccess(Alice, collectionId, { SponsorTimeout: 0 });
+    const tokenId = await createItemExpectSuccess(Alice, collectionId, 'Fungible');
+    await setCollectionSponsorExpectSuccess(collectionId, Alice.address);
+    await confirmSponsorshipExpectSuccess(collectionId, '//Alice');
+    await transferExpectSuccess(collectionId, tokenId, Alice, Bob, 10, 'Fungible');
+    const aliceBalanceBefore = (await getFreeBalance(Alice)).toNumber();
+    await transferExpectSuccess(collectionId, tokenId, Bob, Charlie, 2, 'Fungible');
+
+    // check setting SponsorTimeout = 0, success with next block
+    await waitNewBlocks(1);
+    await transferExpectSuccess(collectionId, tokenId, Bob, Charlie, 2, 'Fungible');
+    const aliceBalanceAfterSponsoredTransaction1 = (await getFreeBalance(Alice)).toNumber();
+    expect(aliceBalanceAfterSponsoredTransaction1).to.be.lessThan(aliceBalanceBefore);
+  });
+});
+
+describe.only('Collection zero limits (ReFungible)', () => {
+  let Alice: IKeyringPair;
+  let Bob: IKeyringPair;
+  let Charlie: IKeyringPair;
+
+  before(async () => {
+    await usingApi(async () => {
+      Alice = privateKey('//Alice');
+      Bob = privateKey('//Bob');
+      Charlie = privateKey('//Charlie');
+    });
+  });
+
+  it('Limits have 0 in tokens per address field, the chain limits are applied', async () => {  
+    const collectionId = await createCollectionExpectSuccess({mode: {type: 'ReFungible' }});
+    await setCollectionLimitsExpectSuccess(Alice, collectionId, { AccountTokenOwnershipLimit: 0 });
+    for(let i = 0; i < 10; i++){
+      await createItemExpectSuccess(Alice, collectionId, 'ReFungible');
+    }
+    await createItemExpectFailure(Alice, collectionId, 'ReFungible');
+  });
+
+  it('Limits have 0 in sponsor timeout, no limits are applied', async () => {
+
+    const collectionId = await createCollectionExpectSuccess({ mode: { type: 'ReFungible' } });
+    await setCollectionLimitsExpectSuccess(Alice, collectionId, { SponsorTimeout: 0 });
+    const tokenId = await createItemExpectSuccess(Alice, collectionId, 'ReFungible');
+    await setCollectionSponsorExpectSuccess(collectionId, Alice.address);
+    await confirmSponsorshipExpectSuccess(collectionId, '//Alice');
+    await transferExpectSuccess(collectionId, tokenId, Alice, Bob, 100, 'ReFungible');
+    await transferExpectSuccess(collectionId, tokenId, Bob, Charlie, 20, 'ReFungible');
+    const aliceBalanceBefore = (await getFreeBalance(Alice)).toNumber();
+
+    // check setting SponsorTimeout = 0, success with next block
+    await waitNewBlocks(1);
+    await transferExpectSuccess(collectionId, tokenId, Bob, Charlie, 20, 'ReFungible');
+    const aliceBalanceAfterSponsoredTransaction1 = (await getFreeBalance(Alice)).toNumber();
+    expect(aliceBalanceAfterSponsoredTransaction1).to.be.lessThan(aliceBalanceBefore);
+  });
+});
modifiedtests/src/util/helpers.tsdiffbeforeafterboth
--- a/tests/src/util/helpers.ts
+++ b/tests/src/util/helpers.ts
@@ -797,6 +797,17 @@
 }
 
 export async function
+getFreeBalance(account: IKeyringPair) : Promise<BigNumber>
+{
+  let balance = new BigNumber(0) ;
+  await usingApi(async (api) => { 
+    balance = new BigNumber((await api.query.system.account(account.address)).data.free.toString());  
+  });
+
+  return balance;
+}
+
+export async function
 scheduleTransferExpectSuccess(
   collectionId: number,
   tokenId: number,
@@ -870,8 +881,11 @@
     if (type === 'ReFungible') {
       const nftItemData =
         (await api.query.nft.reFungibleItemList(collectionId, tokenId)).toJSON() as unknown as IReFungibleTokenDataType;
-      expect(nftItemData.Owner[0].Owner).to.be.deep.equal(to);
-      expect(nftItemData.Owner[0].Fraction.toString()).to.be.equal(value.toString());
+      const expectedOwner = toSubstrateAddress(to);
+      const ownerIndex = nftItemData.Owner.findIndex(v => toSubstrateAddress(v.Owner as any as string) == expectedOwner);
+      expect(ownerIndex).to.not.equal(-1);
+      expect(nftItemData.Owner[ownerIndex].Owner).to.be.deep.equal(normalizeAccountId(to));
+      expect(nftItemData.Owner[ownerIndex].Fraction).to.be.greaterThanOrEqual(value as number);
     }
   });
 }
@@ -1171,4 +1185,21 @@
 
 export async function queryNftOwner(api: ApiPromise, collectionId: number, tokenId: number): Promise<CrossAccountId> {
   return normalizeAccountId((await api.query.nft.nftItemList(collectionId, tokenId) as any).toJSON().Owner);
-}
\ No newline at end of file
+}
+
+export async function waitNewBlocks(blocksCount = 1): Promise<void> {
+  await usingApi(async (api) => {
+    const promise = new Promise<void>(async (resolve) => {
+      
+      const unsubscribe = await api.rpc.chain.subscribeNewHeads(() => {
+        if (blocksCount > 0) {
+          blocksCount--;
+        } else {
+          unsubscribe();
+          resolve();
+        }
+      });
+    });
+    return promise;
+  });
+}