git.delta.rocks / unique-network / refs/commits / e7f81f393f61

--- a/tests/src/eth/collectionProperties.test.ts
+++ b/tests/src/eth/collectionProperties.test.ts
@@ -18,7 +18,6 @@
 import {Pallets} from '../util';
 import {IProperty, ITokenPropertyPermission} from '../util/playgrounds/types';
 import {IKeyringPair} from '@polkadot/types/types';
-import {TCollectionMode} from '../util/playgrounds/types';
 
 describe('EVM collection properties', () => {
   let donor: IKeyringPair;
@@ -31,7 +30,26 @@
     });
   });
 
-  itEth('Can be set', async({helper}) => {
+  // Soft-deprecated: setCollectionProperty
+  [
+    {method: 'setCollectionProperties', methodParams: [[{key: 'testKey1', value: Buffer.from('testValue1')}, {key: 'testKey2', value: Buffer.from('testValue2')}]], expectedProps: [{key: 'testKey1', value: 'testValue1'}, {key: 'testKey2', value: 'testValue2'}]}, 
+    {method: 'setCollectionProperty', methodParams: ['testKey', Buffer.from('testValue')], expectedProps: [{key: 'testKey', value: 'testValue'}]},
+  ].map(testCase => 
+    itEth(`Collection properties can be set: ${testCase.method}`, async({helper}) => {
+      const caller = await helper.eth.createAccountWithBalance(donor);
+      const collection = await helper.nft.mintCollection(alice, {name: 'name', description: 'test', tokenPrefix: 'test', properties: []});
+      await collection.addAdmin(alice, {Ethereum: caller});
+
+      const address = helper.ethAddress.fromCollectionId(collection.collectionId);
+      const contract = helper.ethNativeContract.collection(address, 'nft', caller, testCase.method === 'setCollectionProperty');
+
+      await contract.methods[testCase.method](...testCase.methodParams).send({from: caller});
+
+      const raw = (await collection.getData())?.raw;
+      expect(raw.properties).to.deep.equal(testCase.expectedProps);
+    }));
+
+  itEth('Cannot set invalid properties', async({helper}) => {
     const caller = await helper.eth.createAccountWithBalance(donor);
     const collection = await helper.nft.mintCollection(alice, {name: 'name', description: 'test', tokenPrefix: 'test', properties: []});
     await collection.addAdmin(alice, {Ethereum: caller});
@@ -39,28 +57,60 @@
     const address = helper.ethAddress.fromCollectionId(collection.collectionId);
     const contract = helper.ethNativeContract.collection(address, 'nft', caller);
 
-    await contract.methods.setCollectionProperties([{key: 'testKey', value: Buffer.from('testValue')}]).send({from: caller});
-
+    await expect(contract.methods.setCollectionProperties([{key: '', value: Buffer.from('val1')}]).send({from: caller})).to.be.rejected;
+    await expect(contract.methods.setCollectionProperties([{key: 'déjà vu', value: Buffer.from('hmm...')}]).send({from: caller})).to.be.rejected;
+    await expect(contract.methods.setCollectionProperties([{key: 'a'.repeat(257), value: Buffer.from('val3')}]).send({from: caller})).to.be.rejected;
+    // TODO add more expects
     const raw = (await collection.getData())?.raw;
-
-    expect(raw.properties[0].value).to.equal('testValue');
+    expect(raw.properties).to.deep.equal([]);
   });
 
-  itEth('Can be deleted', async({helper}) => {
-    const caller = await helper.eth.createAccountWithBalance(donor);
-    const collection = await helper.nft.mintCollection(alice, {name: 'name', description: 'test', tokenPrefix: 'test', properties: [{key: 'testKey', value: 'testValue'}]});
-
-    await collection.addAdmin(alice, {Ethereum: caller});
 
-    const address = helper.ethAddress.fromCollectionId(collection.collectionId);
-    const contract = helper.ethNativeContract.collection(address, 'nft', caller);
+  // Soft-deprecated: deleteCollectionProperty
+  [
+    {method: 'deleteCollectionProperties', methodParams: [['testKey1', 'testKey2']], expectedProps: [{key: 'testKey3', value: 'testValue3'}]},
+    {method: 'deleteCollectionProperty', methodParams: ['testKey1'], expectedProps: [{key: 'testKey2', value: 'testValue2'}, {key: 'testKey3', value: 'testValue3'}]}, 
+  ].map(testCase => 
+    itEth(`Collection properties can be deleted: ${testCase.method}()`, async({helper}) => {
+      const properties = [
+        {key: 'testKey1', value: 'testValue1'},
+        {key: 'testKey2', value: 'testValue2'},
+        {key: 'testKey3', value: 'testValue3'}];
+      const caller = await helper.eth.createAccountWithBalance(donor);
+      const collection = await helper.nft.mintCollection(alice, {name: 'name', description: 'test', tokenPrefix: 'test', properties});
+  
+      await collection.addAdmin(alice, {Ethereum: caller});
+  
+      const address = helper.ethAddress.fromCollectionId(collection.collectionId);
+      const contract = helper.ethNativeContract.collection(address, 'nft', caller, testCase.method === 'deleteCollectionProperty');
+  
+      await contract.methods[testCase.method](...testCase.methodParams).send({from: caller});
+  
+      const raw = (await collection.getData())?.raw;
+  
+      expect(raw.properties.length).to.equal(testCase.expectedProps.length);
+      expect(raw.properties).to.deep.equal(testCase.expectedProps);
+    }));
 
-    await contract.methods.deleteCollectionProperties(['testKey']).send({from: caller});
+  
+  [
+    {method: 'deleteCollectionProperties', methodParams: [['testKey2']]},
+    {method: 'deleteCollectionProperty', methodParams: ['testKey2']},
+  ].map(testCase => 
+    itEth(`cannot ${testCase.method}() of non-owned collections`, async ({helper}) => {
+      const properties = [
+        {key: 'testKey1', value: 'testValue1'},
+        {key: 'testKey2', value: 'testValue2'},
+      ];
+      const caller = await helper.eth.createAccountWithBalance(donor);
+      const collection = await helper.nft.mintCollection(alice, {name: 'name', description: 'test', tokenPrefix: 'test', properties});
 
-    const raw = (await collection.getData())?.raw;
+      const address = helper.ethAddress.fromCollectionId(collection.collectionId);
+      const collectionEvm = helper.ethNativeContract.collection(address, 'nft', caller, testCase.method === 'deleteCollectionProperty');
 
-    expect(raw.properties.length).to.equal(0);
-  });
+      await expect(collectionEvm.methods[testCase.method](...testCase.methodParams).send({from: caller})).to.be.rejected;
+      expect(await collection.getProperties()).to.deep.eq(properties);
+    }));
 
   itEth('Can be read', async({helper}) => {
     const caller = helper.eth.createAccount();
@@ -72,39 +122,6 @@
     const value = await contract.methods.collectionProperty('testKey').call();
     expect(value).to.equal(helper.getWeb3().utils.toHex('testValue'));
   });
-
-  // Soft-deprecated
-  itEth('Collection property can be set', async({helper}) => {
-    const caller = await helper.eth.createAccountWithBalance(donor);
-    const collection = await helper.nft.mintCollection(alice, {name: 'name', description: 'test', tokenPrefix: 'test', properties: []});
-    await collection.addAdmin(alice, {Ethereum: caller});
-
-    const address = helper.ethAddress.fromCollectionId(collection.collectionId);
-    const contract = helper.ethNativeContract.collection(address, 'nft', caller, true);
-
-    await contract.methods.setCollectionProperty('testKey', Buffer.from('testValue')).send();
-
-    const raw = (await collection.getData())?.raw;
-
-    expect(raw.properties[0].value).to.equal('testValue');
-  });
-
-  // Soft-deprecated
-  itEth('Collection property can be deleted', async({helper}) => {
-    const caller = await helper.eth.createAccountWithBalance(donor);
-    const collection = await helper.nft.mintCollection(alice, {name: 'name', description: 'test', tokenPrefix: 'test', properties: [{key: 'testKey', value: 'testValue'}]});
-
-    await collection.addAdmin(alice, {Ethereum: caller});
-
-    const address = helper.ethAddress.fromCollectionId(collection.collectionId);
-    const contract = helper.ethNativeContract.collection(address, 'nft', caller, true);
-
-    await contract.methods.deleteCollectionProperty('testKey').send({from: caller});
-
-    const raw = (await collection.getData())?.raw;
-
-    expect(raw.properties.length).to.equal(0);
-  });
 });
 
 describe('Supports ERC721Metadata', () => {
@@ -116,85 +133,81 @@
     });
   });
 
-  const checkERC721Metadata = async (helper: EthUniqueHelper, mode: 'nft' | 'rft') => {
-    const caller = await helper.eth.createAccountWithBalance(donor);
-    const bruh = await helper.eth.createAccountWithBalance(donor);
-
-    const BASE_URI = 'base/';
-    const SUFFIX = 'suffix1';
-    const URI = 'uri1';
-
-    const collectionHelpers = helper.ethNativeContract.collectionHelpers(caller);
-    const creatorMethod = mode === 'rft' ? 'createRFTCollection' : 'createNFTCollection';
-
-    const {collectionId, collectionAddress} = await helper.eth[creatorMethod](caller, 'n', 'd', 'p');
-    const bruhCross = helper.ethCrossAccount.fromAddress(bruh);
-
-    const contract = helper.ethNativeContract.collectionById(collectionId, mode, caller);
-    await contract.methods.addCollectionAdminCross(bruhCross).send(); // to check that admin will work too
-
-    const collection1 = helper.nft.getCollectionObject(collectionId);
-    const data1 = await collection1.getData();
-    expect(data1?.raw.flags.erc721metadata).to.be.false;
-    expect(await contract.methods.supportsInterface('0x5b5e139f').call()).to.be.false;
-
-    await collectionHelpers.methods.makeCollectionERC721MetadataCompatible(collectionAddress, BASE_URI)
-      .send({from: bruh});
-
-    expect(await contract.methods.supportsInterface('0x5b5e139f').call()).to.be.true;
-
-    const collection2 = helper.nft.getCollectionObject(collectionId);
-    const data2 = await collection2.getData();
-    expect(data2?.raw.flags.erc721metadata).to.be.true;
-
-    const propertyPermissions = data2?.raw.tokenPropertyPermissions;
-    expect(propertyPermissions?.length).to.equal(2);
-
-    expect(propertyPermissions.find((tpp: ITokenPropertyPermission) => {
-      return tpp.key === 'URI' && tpp.permission.mutable && tpp.permission.collectionAdmin && !tpp.permission.tokenOwner;
-    })).to.be.not.null;
-
-    expect(propertyPermissions.find((tpp: ITokenPropertyPermission) => {
-      return tpp.key === 'URISuffix' && tpp.permission.mutable && tpp.permission.collectionAdmin && !tpp.permission.tokenOwner;
-    })).to.be.not.null;
-
-    expect(data2?.raw.properties?.find((property: IProperty) => {
-      return property.key === 'baseURI' && property.value === BASE_URI;
-    })).to.be.not.null;
-
-    const token1Result = await contract.methods.mint(bruh).send();
-    const tokenId1 = token1Result.events.Transfer.returnValues.tokenId;
-
-    expect(await contract.methods.tokenURI(tokenId1).call()).to.equal(BASE_URI);
-
-    await contract.methods.setProperties(tokenId1, [{key: 'URISuffix', value: Buffer.from(SUFFIX)}]).send();
-    expect(await contract.methods.tokenURI(tokenId1).call()).to.equal(BASE_URI + SUFFIX);
-
-    await contract.methods.setProperties(tokenId1, [{key: 'URI', value: Buffer.from(URI)}]).send();
-    expect(await contract.methods.tokenURI(tokenId1).call()).to.equal(URI);
-
-    await contract.methods.deleteProperties(tokenId1, ['URI']).send();
-    expect(await contract.methods.tokenURI(tokenId1).call()).to.equal(BASE_URI + SUFFIX);
-
-    const token2Result = await contract.methods.mintWithTokenURI(bruh, URI).send();
-    const tokenId2 = token2Result.events.Transfer.returnValues.tokenId;
-
-    expect(await contract.methods.tokenURI(tokenId2).call()).to.equal(URI);
-
-    await contract.methods.deleteProperties(tokenId2, ['URI']).send();
-    expect(await contract.methods.tokenURI(tokenId2).call()).to.equal(BASE_URI);
-
-    await contract.methods.setProperties(tokenId2, [{key: 'URISuffix', value: Buffer.from(SUFFIX)}]).send();
-    expect(await contract.methods.tokenURI(tokenId2).call()).to.equal(BASE_URI + SUFFIX);
-  };
-
-  itEth('ERC721Metadata property can be set for NFT collection', async({helper}) => {
-    await checkERC721Metadata(helper, 'nft');
-  });
-
-  itEth.ifWithPallets('ERC721Metadata property can be set for RFT collection', [Pallets.ReFungible], async({helper}) => {
-    await checkERC721Metadata(helper, 'rft');
-  });
+  [
+    {case: 'nft' as const},
+    {case: 'rft' as const, requiredPallets: [Pallets.ReFungible]},
+  ].map(testCase => 
+    itEth.ifWithPallets(`ERC721Metadata property can be set for ${testCase.case} collection`, testCase.requiredPallets || [], async ({helper}) => {
+      const caller = await helper.eth.createAccountWithBalance(donor);
+      const bruh = await helper.eth.createAccountWithBalance(donor);
+  
+      const BASE_URI = 'base/';
+      const SUFFIX = 'suffix1';
+      const URI = 'uri1';
+  
+      const collectionHelpers = helper.ethNativeContract.collectionHelpers(caller);
+      const creatorMethod = testCase.case === 'rft' ? 'createRFTCollection' : 'createNFTCollection';
+  
+      const {collectionId, collectionAddress} = await helper.eth[creatorMethod](caller, 'n', 'd', 'p');
+      const bruhCross = helper.ethCrossAccount.fromAddress(bruh);
+  
+      const contract = helper.ethNativeContract.collectionById(collectionId, testCase.case, caller);
+      await contract.methods.addCollectionAdminCross(bruhCross).send(); // to check that admin will work too
+  
+      const collection1 = helper.nft.getCollectionObject(collectionId);
+      const data1 = await collection1.getData();
+      expect(data1?.raw.flags.erc721metadata).to.be.false;
+      expect(await contract.methods.supportsInterface('0x5b5e139f').call()).to.be.false;
+  
+      await collectionHelpers.methods.makeCollectionERC721MetadataCompatible(collectionAddress, BASE_URI)
+        .send({from: bruh});
+  
+      expect(await contract.methods.supportsInterface('0x5b5e139f').call()).to.be.true;
+  
+      const collection2 = helper.nft.getCollectionObject(collectionId);
+      const data2 = await collection2.getData();
+      expect(data2?.raw.flags.erc721metadata).to.be.true;
+  
+      const propertyPermissions = data2?.raw.tokenPropertyPermissions;
+      expect(propertyPermissions?.length).to.equal(2);
+  
+      expect(propertyPermissions.find((tpp: ITokenPropertyPermission) => {
+        return tpp.key === 'URI' && tpp.permission.mutable && tpp.permission.collectionAdmin && !tpp.permission.tokenOwner;
+      })).to.be.not.null;
+  
+      expect(propertyPermissions.find((tpp: ITokenPropertyPermission) => {
+        return tpp.key === 'URISuffix' && tpp.permission.mutable && tpp.permission.collectionAdmin && !tpp.permission.tokenOwner;
+      })).to.be.not.null;
+  
+      expect(data2?.raw.properties?.find((property: IProperty) => {
+        return property.key === 'baseURI' && property.value === BASE_URI;
+      })).to.be.not.null;
+  
+      const token1Result = await contract.methods.mint(bruh).send();
+      const tokenId1 = token1Result.events.Transfer.returnValues.tokenId;
+  
+      expect(await contract.methods.tokenURI(tokenId1).call()).to.equal(BASE_URI);
+  
+      await contract.methods.setProperties(tokenId1, [{key: 'URISuffix', value: Buffer.from(SUFFIX)}]).send();
+      expect(await contract.methods.tokenURI(tokenId1).call()).to.equal(BASE_URI + SUFFIX);
+  
+      await contract.methods.setProperties(tokenId1, [{key: 'URI', value: Buffer.from(URI)}]).send();
+      expect(await contract.methods.tokenURI(tokenId1).call()).to.equal(URI);
+  
+      await contract.methods.deleteProperties(tokenId1, ['URI']).send();
+      expect(await contract.methods.tokenURI(tokenId1).call()).to.equal(BASE_URI + SUFFIX);
+  
+      const token2Result = await contract.methods.mintWithTokenURI(bruh, URI).send();
+      const tokenId2 = token2Result.events.Transfer.returnValues.tokenId;
+  
+      expect(await contract.methods.tokenURI(tokenId2).call()).to.equal(URI);
+  
+      await contract.methods.deleteProperties(tokenId2, ['URI']).send();
+      expect(await contract.methods.tokenURI(tokenId2).call()).to.equal(BASE_URI);
+  
+      await contract.methods.setProperties(tokenId2, [{key: 'URISuffix', value: Buffer.from(SUFFIX)}]).send();
+      expect(await contract.methods.tokenURI(tokenId2).call()).to.equal(BASE_URI + SUFFIX);
+    }));
 });
 
 describe('EVM collection property', () => {
@@ -206,81 +219,70 @@
     });
   });
 
-  async function testSetReadProperties(helper: EthUniqueHelper, mode: TCollectionMode) {
-    const collection = await helper[mode].mintCollection(donor, {name: 'A', description: 'B', tokenPrefix: 'C'});
-
-    const sender = await helper.eth.createAccountWithBalance(donor, 100n);
-    await collection.addAdmin(donor, {Ethereum: sender});
-
-    const collectionAddress = helper.ethAddress.fromCollectionId(collection.collectionId);
-    const contract = helper.ethNativeContract.collection(collectionAddress, mode, sender);
-
-    const keys = ['key0', 'key1'];
-
-    const writeProperties = [
-      helper.ethProperty.property(keys[0], 'value0'),
-      helper.ethProperty.property(keys[1], 'value1'),
-    ];
-
-    await contract.methods.setCollectionProperties(writeProperties).send();
-    const readProperties = await contract.methods.collectionProperties([keys[0], keys[1]]).call();
-    expect(readProperties).to.be.like(writeProperties);
-  }
-
-  itEth('Set/read properties ft', async ({helper}) => {
-    await testSetReadProperties(helper, 'ft');
-  });
-  itEth.ifWithPallets('Set/read properties rft', [Pallets.ReFungible], async ({helper}) => {
-    await testSetReadProperties(helper, 'rft');
-  });
-  itEth('Set/read properties nft', async ({helper}) => {
-    await testSetReadProperties(helper, 'nft');
-  });
-
-  async function testDeleteProperties(helper: EthUniqueHelper, mode: TCollectionMode) {
-    const collection = await helper[mode].mintCollection(donor, {name: 'A', description: 'B', tokenPrefix: 'C'});
-
-    const sender = await helper.eth.createAccountWithBalance(donor, 100n);
-    await collection.addAdmin(donor, {Ethereum: sender});
-
-    const collectionAddress = helper.ethAddress.fromCollectionId(collection.collectionId);
-    const contract = helper.ethNativeContract.collection(collectionAddress, mode, sender);
+  [
+    {case: 'nft' as const},
+    {case: 'rft' as const, requiredPallets: [Pallets.ReFungible]},
+    {case: 'ft' as const},
+  ].map(testCase => 
+    itEth.ifWithPallets(`can set/read properties ${testCase.case}`, testCase.requiredPallets || [], async ({helper}) => {
+      const collection = await helper[testCase.case].mintCollection(donor, {name: 'A', description: 'B', tokenPrefix: 'C'});
 
-    const keys = ['key0', 'key1', 'key2', 'key3'];
-
-    {
+      const sender = await helper.eth.createAccountWithBalance(donor, 100n);
+      await collection.addAdmin(donor, {Ethereum: sender});
+  
+      const collectionAddress = helper.ethAddress.fromCollectionId(collection.collectionId);
+      const contract = helper.ethNativeContract.collection(collectionAddress, testCase.case, sender);
+  
+      const keys = ['key0', 'key1'];
+  
       const writeProperties = [
         helper.ethProperty.property(keys[0], 'value0'),
         helper.ethProperty.property(keys[1], 'value1'),
-        helper.ethProperty.property(keys[2], 'value2'),
-        helper.ethProperty.property(keys[3], 'value3'),
       ];
-
+  
       await contract.methods.setCollectionProperties(writeProperties).send();
-      const readProperties = await contract.methods.collectionProperties([keys[0], keys[1], keys[2], keys[3]]).call();
+      const readProperties = await contract.methods.collectionProperties([keys[0], keys[1]]).call();
       expect(readProperties).to.be.like(writeProperties);
-    }
+    }));
 
-    {
-      const expectProperties = [
-        helper.ethProperty.property(keys[0], 'value0'),
-        helper.ethProperty.property(keys[1], 'value1'),
-      ];
+  [
+    {case: 'nft' as const},
+    {case: 'rft' as const, requiredPallets: [Pallets.ReFungible]},
+    {case: 'ft' as const},
+  ].map(testCase => 
+    itEth.ifWithPallets(`can delete properties ${testCase.case}`, testCase.requiredPallets || [], async ({helper}) => {
+      const collection = await helper[testCase.case].mintCollection(donor, {name: 'A', description: 'B', tokenPrefix: 'C'});
 
-      await contract.methods.deleteCollectionProperties([keys[2], keys[3]]).send();
-      const readProperties = await contract.methods.collectionProperties([]).call();
-      expect(readProperties).to.be.like(expectProperties);
-    }
-  }
+      const sender = await helper.eth.createAccountWithBalance(donor, 100n);
+      await collection.addAdmin(donor, {Ethereum: sender});
+  
+      const collectionAddress = helper.ethAddress.fromCollectionId(collection.collectionId);
+      const contract = helper.ethNativeContract.collection(collectionAddress, testCase.case, sender);
   
-  itEth('Delete properties ft', async ({helper}) => {
-    await testDeleteProperties(helper, 'ft');
-  });
-  itEth.ifWithPallets('Delete properties rft', [Pallets.ReFungible], async ({helper}) => {
-    await testDeleteProperties(helper, 'rft');
-  });
-  itEth('Delete properties nft', async ({helper}) => {
-    await testDeleteProperties(helper, 'nft');
-  });
-    
+      const keys = ['key0', 'key1', 'key2', 'key3'];
+  
+      {
+        const writeProperties = [
+          helper.ethProperty.property(keys[0], 'value0'),
+          helper.ethProperty.property(keys[1], 'value1'),
+          helper.ethProperty.property(keys[2], 'value2'),
+          helper.ethProperty.property(keys[3], 'value3'),
+        ];
+  
+        await contract.methods.setCollectionProperties(writeProperties).send();
+        const readProperties = await contract.methods.collectionProperties([keys[0], keys[1], keys[2], keys[3]]).call();
+        expect(readProperties).to.be.like(writeProperties);
+      }
+  
+      {
+        const expectProperties = [
+          helper.ethProperty.property(keys[0], 'value0'),
+          helper.ethProperty.property(keys[1], 'value1'),
+        ];
+  
+        await contract.methods.deleteCollectionProperties([keys[2], keys[3]]).send();
+        const readProperties = await contract.methods.collectionProperties([]).call();
+        expect(readProperties).to.be.like(expectProperties);
+      }
+    }));
 });

31    });31    });
32  });32  });
33  33  
34  // TODO: move to substrate tests
34  itEth('sponsors mint transactions', async ({helper}) => {35  itEth('sponsors mint transactions', async ({helper}) => {
35    const collection = await helper.nft.mintCollection(alice, {tokenPrefix: 'spnr', permissions: {mintMode: true}});36    const collection = await helper.nft.mintCollection(alice, {tokenPrefix: 'spnr', permissions: {mintMode: true}});
36    await collection.setSponsor(alice, alice.address);37    await collection.setSponsor(alice, alice.address);
81  //   expect(bigIntToSub(api, BigInt(sponsorTuple[1]))).to.be.eq(sponsor.address);82  //   expect(bigIntToSub(api, BigInt(sponsorTuple[1]))).to.be.eq(sponsor.address);
82  // });83  // });
8384
84  // Soft-deprecated85  [
86    'setCollectionSponsorCross',
87    'setCollectionSponsor', // Soft-deprecated
85  itEth('[eth] Remove sponsor', async ({helper}) => {88  ].map(testCase => 
89    itEth(`[${testCase}] can remove collection sponsor`, async ({helper}) => {
86    const owner = await helper.eth.createAccountWithBalance(donor);90      const owner = await helper.eth.createAccountWithBalance(donor);
87    const collectionHelpers = helper.ethNativeContract.collectionHelpers(owner);91      const collectionHelpers = helper.ethNativeContract.collectionHelpers(owner);
92  
93      let result = await collectionHelpers.methods.createNFTCollection('Sponsor collection', '1', '1').send({value: Number(2n * nominal)});
94      const collectionIdAddress = helper.ethAddress.normalizeAddress(result.events.CollectionCreated.returnValues.collectionId);
95      const sponsor = await helper.eth.createAccountWithBalance(donor);
96      const sponsorCross = helper.ethCrossAccount.fromAddress(sponsor);
97      const collectionEvm = helper.ethNativeContract.collection(collectionIdAddress, 'nft', owner, testCase === 'setCollectionSponsor');
98  
99      expect(await collectionEvm.methods.hasCollectionPendingSponsor().call({from: owner})).to.be.false;
100      result = await collectionEvm.methods[testCase](testCase === 'setCollectionSponsor' ? sponsor : sponsorCross).send({from: owner});
101      expect(await collectionEvm.methods.hasCollectionPendingSponsor().call({from: owner})).to.be.true;
102  
103      await collectionEvm.methods.confirmCollectionSponsorship().send({from: sponsor});
104      expect(await collectionEvm.methods.hasCollectionPendingSponsor().call({from: owner})).to.be.false;
105  
106      await collectionEvm.methods.removeCollectionSponsor().send({from: owner});
107  
108      const sponsorTuple = await collectionEvm.methods.collectionSponsor().call({from: owner});
109      expect(sponsorTuple.field_0).to.be.eq('0x0000000000000000000000000000000000000000');
110    }));
88111
89    let result = await collectionHelpers.methods.createNFTCollection('Sponsor collection', '1', '1').send({value: Number(2n * nominal)});112  [
113    'setCollectionSponsorCross',
114    'setCollectionSponsor', // Soft-deprecated
115  ].map(testCase => 
116    itEth(`[${testCase}] Can sponsor from evm address via access list`, async ({helper}) => {
117      const owner = await helper.eth.createAccountWithBalance(donor);
118      const sponsorEth = await helper.eth.createAccountWithBalance(donor);
119      const sponsorCrossEth = helper.ethCrossAccount.fromAddress(sponsorEth);
120  
121      const {collectionId, collectionAddress} = await helper.eth.createERC721MetadataCompatibleNFTCollection(owner, 'Sponsor collection', '1', '1', '');
122  
123      const collectionSub = helper.nft.getCollectionObject(collectionId);
124      const collectionEvm = helper.ethNativeContract.collection(collectionAddress, 'nft', owner, testCase === 'setCollectionSponsor');
125  
126      // Set collection sponsor:
127      await collectionEvm.methods[testCase](testCase === 'setCollectionSponsor' ? sponsorEth : sponsorCrossEth).send({from: owner});
90    const collectionIdAddress = helper.ethAddress.normalizeAddress(result.events.CollectionCreated.returnValues.collectionId);128      let sponsorship = (await collectionSub.getData())!.raw.sponsorship;
129      expect(sponsorship.Unconfirmed).to.be.eq(helper.address.ethToSubstrate(sponsorEth, true));
91    const sponsor = await helper.eth.createAccountWithBalance(donor);130      // Account cannot confirm sponsorship if it is not set as a sponsor
131      await expect(collectionEvm.methods.confirmCollectionSponsorship().call()).to.be.rejectedWith('caller is not set as sponsor');
132      
133      // Sponsor can confirm sponsorship:
134      await collectionEvm.methods.confirmCollectionSponsorship().send({from: sponsorEth});
135      sponsorship = (await collectionSub.getData())!.raw.sponsorship;
136      expect(sponsorship.Confirmed).to.be.eq(helper.address.ethToSubstrate(sponsorEth, true));
137  
138      // Create user with no balance:
139      const user = helper.eth.createAccount();
92    const collectionEvm = helper.ethNativeContract.collection(collectionIdAddress, 'nft', owner, true);140      const userCross = helper.ethCrossAccount.fromAddress(user);
141      const nextTokenId = await collectionEvm.methods.nextTokenId().call();
142      expect(nextTokenId).to.be.equal('1');
143  
144      // Set collection permissions:
145      const oldPermissions = (await collectionSub.getData())!.raw.permissions; // (await getDetailedCollectionInfo(api, collectionId))!.permissions.toHuman();
146      expect(oldPermissions.mintMode).to.be.false;
147      expect(oldPermissions.access).to.be.equal('Normal');
93148
94    expect(await collectionEvm.methods.hasCollectionPendingSponsor().call({from: owner})).to.be.false;149      await collectionEvm.methods.setCollectionAccess(1 /*'AllowList'*/).send({from: owner});
95    result = await collectionEvm.methods.setCollectionSponsor(sponsor).send({from: owner});150      await collectionEvm.methods.addToCollectionAllowListCross(userCross).send({from: owner});
96    expect(await collectionEvm.methods.hasCollectionPendingSponsor().call({from: owner})).to.be.true;151      await collectionEvm.methods.setCollectionMintMode(true).send({from: owner});
152  
153      const newPermissions = (await collectionSub.getData())!.raw.permissions; // (await getDetailedCollectionInfo(api, collectionId))!.permissions.toHuman();
154      expect(newPermissions.mintMode).to.be.true;
155      expect(newPermissions.access).to.be.equal('AllowList');
156  
157      const ownerBalanceBefore = await helper.balance.getSubstrate(helper.address.ethToSubstrate(owner));
158      const sponsorBalanceBefore = await helper.balance.getSubstrate(helper.address.ethToSubstrate(sponsorEth));
97159
98    await collectionEvm.methods.confirmCollectionSponsorship().send({from: sponsor});160      // User can mint token without balance:
99    expect(await collectionEvm.methods.hasCollectionPendingSponsor().call({from: owner})).to.be.false;161      {
100162        const result = await collectionEvm.methods.mintWithTokenURI(user, 'Test URI').send({from: user});
101    await collectionEvm.methods.removeCollectionSponsor().send({from: owner});163        const events = helper.eth.normalizeEvents(result.events);
102164  
103    const sponsorTuple = await collectionEvm.methods.collectionSponsor().call({from: owner});165        expect(events).to.be.deep.equal([
104    expect(sponsorTuple.field_0).to.be.eq('0x0000000000000000000000000000000000000000');166          {
105  });167            address: collectionAddress,
106168            event: 'Transfer',
107  itEth('[cross] Remove sponsor', async ({helper}) => {169            args: {
108    const owner = await helper.eth.createAccountWithBalance(donor);170              from: '0x0000000000000000000000000000000000000000',
109    const collectionHelpers = helper.ethNativeContract.collectionHelpers(owner);171              to: user,
110172              tokenId: '1',
111    let result = await collectionHelpers.methods.createNFTCollection('Sponsor collection', '1', '1').send({value: Number(2n * nominal)});173            },
112    const collectionIdAddress = helper.ethAddress.normalizeAddress(result.events.CollectionCreated.returnValues.collectionId);
113    const sponsor = await helper.eth.createAccountWithBalance(donor);
114    const sponsorCross = helper.ethCrossAccount.fromAddress(sponsor);
115    const collectionEvm = helper.ethNativeContract.collection(collectionIdAddress, 'nft', owner);
116
117    expect(await collectionEvm.methods.hasCollectionPendingSponsor().call({from: owner})).to.be.false;
118    result = await collectionEvm.methods.setCollectionSponsorCross(sponsorCross).send({from: owner});
119    expect(await collectionEvm.methods.hasCollectionPendingSponsor().call({from: owner})).to.be.true;
120
121    await collectionEvm.methods.confirmCollectionSponsorship().send({from: sponsor});
122    expect(await collectionEvm.methods.hasCollectionPendingSponsor().call({from: owner})).to.be.false;
123
124    await collectionEvm.methods.removeCollectionSponsor().send({from: owner});
125
126    const sponsorTuple = await collectionEvm.methods.collectionSponsor().call({from: owner});
127    expect(sponsorTuple.field_0).to.be.eq('0x0000000000000000000000000000000000000000');
128  });
129
130  // Soft-deprecated
131  itEth('[eth] Sponsoring collection from evm address via access list', async ({helper}) => {
132    const owner = await helper.eth.createAccountWithBalance(donor);
133
134    const {collectionId, collectionAddress} = await helper.eth.createERC721MetadataCompatibleNFTCollection(owner, 'Sponsor collection', '1', '1', '');
135
136    const collection = helper.nft.getCollectionObject(collectionId);
137    const sponsor = await helper.eth.createAccountWithBalance(donor);
138    const collectionEvm = helper.ethNativeContract.collection(collectionAddress, 'nft', owner, true);
139
140    await collectionEvm.methods.setCollectionSponsor(sponsor).send({from: owner});
141    let collectionData = (await collection.getData())!;
142    expect(collectionData.raw.sponsorship.Unconfirmed).to.be.eq(helper.address.ethToSubstrate(sponsor, true));
143    await expect(collectionEvm.methods.confirmCollectionSponsorship().call()).to.be.rejectedWith('caller is not set as sponsor');
144
145    await collectionEvm.methods.confirmCollectionSponsorship().send({from: sponsor});
146    collectionData = (await collection.getData())!;
147    expect(collectionData.raw.sponsorship.Confirmed).to.be.eq(helper.address.ethToSubstrate(sponsor, true));
148
149    const user = helper.eth.createAccount();
150    const nextTokenId = await collectionEvm.methods.nextTokenId().call();
151    expect(nextTokenId).to.be.equal('1');
152
153    const oldPermissions = (await collection.getData())!.raw.permissions; // (await getDetailedCollectionInfo(api, collectionId))!.permissions.toHuman();
154    expect(oldPermissions.mintMode).to.be.false;
155    expect(oldPermissions.access).to.be.equal('Normal');
156
157    await collectionEvm.methods.setCollectionAccess(1 /*'AllowList'*/).send({from: owner});
158    await collectionEvm.methods.addToCollectionAllowList(user).send({from: owner});
159    await collectionEvm.methods.setCollectionMintMode(true).send({from: owner});
160
161    const newPermissions = (await collection.getData())!.raw.permissions; // (await getDetailedCollectionInfo(api, collectionId))!.permissions.toHuman();
162    expect(newPermissions.mintMode).to.be.true;
163    expect(newPermissions.access).to.be.equal('AllowList');
164
165    const ownerBalanceBefore = await helper.balance.getSubstrate(helper.address.ethToSubstrate(owner));
166    const sponsorBalanceBefore = await helper.balance.getSubstrate(helper.address.ethToSubstrate(sponsor));
167
168    {
169      const result = await collectionEvm.methods.mintWithTokenURI(user, 'Test URI').send({from: user});
170      const events = helper.eth.normalizeEvents(result.events);
171
172      expect(events).to.be.deep.equal([
173        {
174          address: collectionAddress,
175          event: 'Transfer',
176          args: {
177            from: '0x0000000000000000000000000000000000000000',
178            to: user,
179            tokenId: '1',
180          },174          },
181        },175        ]);
182      ]);176  
177        const ownerBalanceAfter = await helper.balance.getSubstrate(helper.address.ethToSubstrate(owner));
178        const sponsorBalanceAfter = await helper.balance.getSubstrate(helper.address.ethToSubstrate(sponsorEth));
179        const userBalanceAfter =  await helper.balance.getSubstrate(helper.address.ethToSubstrate(user));
180  
181        expect(await collectionEvm.methods.tokenURI(nextTokenId).call()).to.be.equal('Test URI');
182        expect(ownerBalanceBefore).to.be.eq(ownerBalanceAfter);
183        expect(userBalanceAfter).to.be.eq(0n);
184        expect(sponsorBalanceBefore > sponsorBalanceAfter).to.be.true;
185      }
186    }));
183187
184      const ownerBalanceAfter = await helper.balance.getSubstrate(await helper.address.ethToSubstrate(owner));
185      const sponsorBalanceAfter = await helper.balance.getSubstrate(await helper.address.ethToSubstrate(sponsor));
186
187      expect(await collectionEvm.methods.tokenURI(nextTokenId).call()).to.be.equal('Test URI');
188      expect(ownerBalanceBefore).to.be.eq(ownerBalanceAfter);
189      expect(sponsorBalanceBefore > sponsorBalanceAfter).to.be.true;
190    }
191  });
192
193  itEth('[cross] Sponsoring collection from evm address via access list', async ({helper}) => {
194    const owner = await helper.eth.createAccountWithBalance(donor);
195
196    const {collectionId, collectionAddress} = await helper.eth.createERC721MetadataCompatibleNFTCollection(owner, 'Sponsor collection', '1', '1', '');
197
198    const collection = helper.nft.getCollectionObject(collectionId);
199    const sponsor = await helper.eth.createAccountWithBalance(donor);
200    const sponsorCross = helper.ethCrossAccount.fromAddress(sponsor);
201    const collectionEvm = helper.ethNativeContract.collection(collectionAddress, 'nft', owner);
202
203    await collectionEvm.methods.setCollectionSponsorCross(sponsorCross).send({from: owner});
204    let collectionData = (await collection.getData())!;
205    expect(collectionData.raw.sponsorship.Unconfirmed).to.be.eq(helper.address.ethToSubstrate(sponsor, true));
206    await expect(collectionEvm.methods.confirmCollectionSponsorship().call()).to.be.rejectedWith('caller is not set as sponsor');
207
208    await collectionEvm.methods.confirmCollectionSponsorship().send({from: sponsor});
209    collectionData = (await collection.getData())!;
210    expect(collectionData.raw.sponsorship.Confirmed).to.be.eq(helper.address.ethToSubstrate(sponsor, true));
211
212    const user = helper.eth.createAccount();
213    const userCross = helper.ethCrossAccount.fromAddress(user);
214    const nextTokenId = await collectionEvm.methods.nextTokenId().call();
215    expect(nextTokenId).to.be.equal('1');
216
217    const oldPermissions = (await collection.getData())!.raw.permissions; // (await getDetailedCollectionInfo(api, collectionId))!.permissions.toHuman();
218    expect(oldPermissions.mintMode).to.be.false;
219    expect(oldPermissions.access).to.be.equal('Normal');
220
221    await collectionEvm.methods.setCollectionAccess(1 /*'AllowList'*/).send({from: owner});
222    await collectionEvm.methods.addToCollectionAllowListCross(userCross).send({from: owner});
223    await collectionEvm.methods.setCollectionMintMode(true).send({from: owner});
224
225    const newPermissions = (await collection.getData())!.raw.permissions; // (await getDetailedCollectionInfo(api, collectionId))!.permissions.toHuman();
226    expect(newPermissions.mintMode).to.be.true;
227    expect(newPermissions.access).to.be.equal('AllowList');
228
229    const ownerBalanceBefore = await helper.balance.getSubstrate(helper.address.ethToSubstrate(owner));
230    const sponsorBalanceBefore = await helper.balance.getSubstrate(helper.address.ethToSubstrate(sponsor));
231
232    {
233      const result = await collectionEvm.methods.mintWithTokenURI(user, 'Test URI').send({from: user});
234      const events = helper.eth.normalizeEvents(result.events);
235
236      expect(events).to.be.deep.equal([
237        {
238          address: collectionAddress,
239          event: 'Transfer',
240          args: {
241            from: '0x0000000000000000000000000000000000000000',
242            to: user,
243            tokenId: '1',
244          },
245        },
246      ]);
247
248      const ownerBalanceAfter = await helper.balance.getSubstrate(await helper.address.ethToSubstrate(owner));
249      const sponsorBalanceAfter = await helper.balance.getSubstrate(await helper.address.ethToSubstrate(sponsor));
250
251      expect(await collectionEvm.methods.tokenURI(nextTokenId).call()).to.be.equal('Test URI');
252      expect(ownerBalanceBefore).to.be.eq(ownerBalanceAfter);
253      expect(sponsorBalanceBefore > sponsorBalanceAfter).to.be.true;
254    }
255  });
256
257  // TODO: Temprorary off. Need refactor188  // TODO: Temprorary off. Need refactor
258  // itWeb3('Sponsoring collection from substrate address via access list', async ({api, web3, privateKeyWrapper}) => {189  // itWeb3('Sponsoring collection from substrate address via access list', async ({api, web3, privateKeyWrapper}) => {
310  //   }241  //   }
311  // });242  // });
312243
313  // Soft-deprecated244  [
245    'setCollectionSponsorCross',
246    'setCollectionSponsor', // Soft-deprecated
314  itEth('[eth] Check that transaction via EVM spend money from sponsor address', async ({helper}) => {247  ].map(testCase => 
248    itEth(`[${testCase}] Check that transaction via EVM spend money from sponsor address`, async ({helper}) => {
315    const owner = await helper.eth.createAccountWithBalance(donor);249      const owner = await helper.eth.createAccountWithBalance(donor);
250      const sponsor = await helper.eth.createAccountWithBalance(donor);
251      const sponsorCross = helper.ethCrossAccount.fromAddress(sponsor);
252  
253      const {collectionAddress, collectionId} = await helper.eth.createERC721MetadataCompatibleNFTCollection(owner,'Sponsor collection', '1', '1', '');
316254
317    const {collectionAddress, collectionId} = await helper.eth.createERC721MetadataCompatibleNFTCollection(owner,'Sponsor collection', '1', '1', '');255      const collectionSub = helper.nft.getCollectionObject(collectionId);
318    const collection = helper.nft.getCollectionObject(collectionId);
319    const sponsor = await helper.eth.createAccountWithBalance(donor);256      const collectionEvm = helper.ethNativeContract.collection(collectionAddress, 'nft', owner, testCase === 'setCollectionSponsor');
320    const collectionEvm = helper.ethNativeContract.collection(collectionAddress, 'nft', owner, true);257      // Set collection sponsor:
321
322    await collectionEvm.methods.setCollectionSponsor(sponsor).send();258      await collectionEvm.methods[testCase](testCase === 'setCollectionSponsor' ? sponsor : sponsorCross).send();
323    let collectionData = (await collection.getData())!;259      let collectionData = (await collectionSub.getData())!;
324    expect(collectionData.raw.sponsorship.Unconfirmed).to.be.eq(helper.address.ethToSubstrate(sponsor, true));260      expect(collectionData.raw.sponsorship.Unconfirmed).to.be.eq(helper.address.ethToSubstrate(sponsor, true));
325    await expect(collectionEvm.methods.confirmCollectionSponsorship().call()).to.be.rejectedWith('caller is not set as sponsor');261      await expect(collectionEvm.methods.confirmCollectionSponsorship().call()).to.be.rejectedWith('caller is not set as sponsor');
326
327    const sponsorCollection = helper.ethNativeContract.collection(collectionAddress, 'nft', sponsor, true);262  
328    await sponsorCollection.methods.confirmCollectionSponsorship().send();263      await collectionEvm.methods.confirmCollectionSponsorship().send({from: sponsor});
329    collectionData = (await collection.getData())!;264      collectionData = (await collectionSub.getData())!;
330    expect(collectionData.raw.sponsorship.Confirmed).to.be.eq(helper.address.ethToSubstrate(sponsor, true));265      expect(collectionData.raw.sponsorship.Confirmed).to.be.eq(helper.address.ethToSubstrate(sponsor, true));
331266  
332    const user = helper.eth.createAccount();267      const user = helper.eth.createAccount();
333    await collectionEvm.methods.addCollectionAdmin(user).send();268      const userCross = helper.ethCrossAccount.fromAddress(user);
334269      await collectionEvm.methods.addCollectionAdminCross(userCross).send();
270  
335    const ownerBalanceBefore = await helper.balance.getSubstrate(helper.address.ethToSubstrate(owner));271      const ownerBalanceBefore = await helper.balance.getSubstrate(helper.address.ethToSubstrate(owner));
336    const sponsorBalanceBefore = await helper.balance.getSubstrate(helper.address.ethToSubstrate(sponsor));272      const sponsorBalanceBefore = await helper.balance.getSubstrate(helper.address.ethToSubstrate(sponsor));
337
338    const userCollectionEvm = helper.ethNativeContract.collection(collectionAddress, 'nft', user, true);273    
339
340    const result = await userCollectionEvm.methods.mintWithTokenURI(user, 'Test URI').send();274      const mintingResult = await collectionEvm.methods.mintWithTokenURI(user, 'Test URI').send({from: user});
341    const tokenId = result.events.Transfer.returnValues.tokenId;275      const tokenId = mintingResult.events.Transfer.returnValues.tokenId;
342276  
343    const events = helper.eth.normalizeEvents(result.events);277      const events = helper.eth.normalizeEvents(mintingResult.events);
344    const address = helper.ethAddress.fromCollectionId(collectionId);278      const address = helper.ethAddress.fromCollectionId(collectionId);
345279  
346    expect(events).to.be.deep.equal([280      expect(events).to.be.deep.equal([
347      {281        {
348        address,282          address,
349        event: 'Transfer',283          event: 'Transfer',
350        args: {284          args: {
351          from: '0x0000000000000000000000000000000000000000',285            from: '0x0000000000000000000000000000000000000000',
352          to: user,286            to: user,
353          tokenId: '1',287            tokenId: '1',
288          },
354        },289        },
355      },290      ]);
356    ]);
357    expect(await userCollectionEvm.methods.tokenURI(tokenId).call()).to.be.equal('Test URI');291      expect(await collectionEvm.methods.tokenURI(tokenId).call({from: user})).to.be.equal('Test URI');
292  
293      const ownerBalanceAfter = await helper.balance.getSubstrate(helper.address.ethToSubstrate(owner));
294      expect(ownerBalanceAfter).to.be.eq(ownerBalanceBefore);
295      const sponsorBalanceAfter = await helper.balance.getSubstrate(helper.address.ethToSubstrate(sponsor));
296      expect(sponsorBalanceAfter < sponsorBalanceBefore).to.be.true;
297    }));
358298
359    const ownerBalanceAfter = await helper.balance.getSubstrate(helper.address.ethToSubstrate(owner));299  itEth('Can reassign collection sponsor', async ({helper}) => {
360    expect(ownerBalanceAfter).to.be.eq(ownerBalanceBefore);
361    const sponsorBalanceAfter = await helper.balance.getSubstrate(helper.address.ethToSubstrate(sponsor));
362    expect(sponsorBalanceAfter < sponsorBalanceBefore).to.be.true;
363  });
364
365  itEth('[cross] Check that transaction via EVM spend money from sponsor address', async ({helper}) => {
366    const owner = await helper.eth.createAccountWithBalance(donor);300    const owner = await helper.eth.createAccountWithBalance(donor);
301    const sponsorEth = await helper.eth.createAccountWithBalance(donor);
302    const sponsorCrossEth = helper.ethCrossAccount.fromAddress(sponsorEth);
303    const [sponsorSub] = await helper.arrange.createAccounts([100n], donor);
304    const sponsorCrossSub = helper.ethCrossAccount.fromKeyringPair(sponsorSub);
367305
368    const {collectionAddress, collectionId} = await helper.eth.createERC721MetadataCompatibleNFTCollection(owner,'Sponsor collection', '1', '1', '');306    const {collectionAddress, collectionId} = await helper.eth.createERC721MetadataCompatibleNFTCollection(owner,'Sponsor collection', '1', '1', '');
369    const collection = helper.nft.getCollectionObject(collectionId);307    const collectionSub = helper.nft.getCollectionObject(collectionId);
370    const sponsor = await helper.eth.createAccountWithBalance(donor);
371    const sponsorCross = helper.ethCrossAccount.fromAddress(sponsor);
372    const collectionEvm = helper.ethNativeContract.collection(collectionAddress, 'nft', owner);308    const collectionEvm = helper.ethNativeContract.collection(collectionAddress, 'nft', owner);
373309
374    await collectionEvm.methods.setCollectionSponsorCross(sponsorCross).send();310    // Set and confirm sponsor:
375    let collectionData = (await collection.getData())!;
376    expect(collectionData.raw.sponsorship.Unconfirmed).to.be.eq(helper.address.ethToSubstrate(sponsor, true));
377    await expect(collectionEvm.methods.confirmCollectionSponsorship().call()).to.be.rejectedWith('caller is not set as sponsor');311    await collectionEvm.methods.setCollectionSponsorCross(sponsorCrossEth).send({from: owner});
378
379    const sponsorCollection = helper.ethNativeContract.collection(collectionAddress, 'nft', sponsor);
380    await sponsorCollection.methods.confirmCollectionSponsorship().send();
381    collectionData = (await collection.getData())!;
382    expect(collectionData.raw.sponsorship.Confirmed).to.be.eq(helper.address.ethToSubstrate(sponsor, true));312    await collectionEvm.methods.confirmCollectionSponsorship().send({from: sponsorEth});
383
384    const user = helper.eth.createAccount();
385    const userCross = helper.ethCrossAccount.fromAddress(user);
386    await collectionEvm.methods.addCollectionAdminCross(userCross).send();
387
388    const ownerBalanceBefore = await helper.balance.getSubstrate(helper.address.ethToSubstrate(owner));
389    const sponsorBalanceBefore = await helper.balance.getSubstrate(helper.address.ethToSubstrate(sponsor));
390
391    const userCollectionEvm = helper.ethNativeContract.collection(collectionAddress, 'nft', user);
392
393    const result = await userCollectionEvm.methods.mintWithTokenURI(user, 'Test URI').send();
394    const tokenId = result.events.Transfer.returnValues.tokenId;
395
396    const events = helper.eth.normalizeEvents(result.events);
397    const address = helper.ethAddress.fromCollectionId(collectionId);
398
399    expect(events).to.be.deep.equal([
400      {
401        address,
402        event: 'Transfer',
403        args: {
404          from: '0x0000000000000000000000000000000000000000',
405          to: user,
406          tokenId: '1',
407        },
408      },
409    ]);
410    expect(await userCollectionEvm.methods.tokenURI(tokenId).call()).to.be.equal('Test URI');
411313
412    const ownerBalanceAfter = await helper.balance.getSubstrate(helper.address.ethToSubstrate(owner));314    // Can reassign sponsor:
413    expect(ownerBalanceAfter).to.be.eq(ownerBalanceBefore);315    await collectionEvm.methods.setCollectionSponsorCross(sponsorCrossSub).send({from: owner});
414    const sponsorBalanceAfter = await helper.balance.getSubstrate(helper.address.ethToSubstrate(sponsor));316    const collectionSponsor = (await collectionSub.getData())?.raw.sponsorship;
415    expect(sponsorBalanceAfter < sponsorBalanceBefore).to.be.true;317    expect(collectionSponsor).to.deep.eq({Unconfirmed: sponsorSub.address});
416  });318  });
417});319});
418320

--- a/tests/src/eth/createFTCollection.test.ts
+++ b/tests/src/eth/createFTCollection.test.ts
@@ -79,56 +79,6 @@
     expect(await collection.methods.description().call()).to.deep.equal(description);
   });
 
-  itEth('Set limits', async ({helper}) => {
-    const owner = await helper.eth.createAccountWithBalance(donor);
-    const {collectionId, collectionAddress} = await helper.eth.createFungibleCollection(owner, 'Limits', DECIMALS, 'absolutely anything', 'INSI');
-    const limits = {
-      accountTokenOwnershipLimit: 1000,
-      sponsoredDataSize: 1024,
-      sponsoredDataRateLimit: 30,
-      tokenLimit: 1000000,
-      sponsorTransferTimeout: 6,
-      sponsorApproveTimeout: 6,
-      ownerCanTransfer: 0,
-      ownerCanDestroy: 0,
-      transfersEnabled: 0,
-    };
-    
-    const expectedLimits = {
-      accountTokenOwnershipLimit: 1000,
-      sponsoredDataSize: 1024,
-      sponsoredDataRateLimit: 30,
-      tokenLimit: 1000000,
-      sponsorTransferTimeout: 6,
-      sponsorApproveTimeout: 6,
-      ownerCanTransfer: false,
-      ownerCanDestroy: false,
-      transfersEnabled: false,
-    };
-   
-    const collection = helper.ethNativeContract.collection(collectionAddress, 'ft', owner);
-    await collection.methods.setCollectionLimit('accountTokenOwnershipLimit', limits.accountTokenOwnershipLimit).send();
-    await collection.methods.setCollectionLimit('sponsoredDataSize', limits.sponsoredDataSize).send();
-    await collection.methods.setCollectionLimit('sponsoredDataRateLimit', limits.sponsoredDataRateLimit).send();
-    await collection.methods.setCollectionLimit('tokenLimit', limits.tokenLimit).send();
-    await collection.methods.setCollectionLimit('sponsorTransferTimeout', limits.sponsorTransferTimeout).send();
-    await collection.methods.setCollectionLimit('sponsorApproveTimeout', limits.sponsorApproveTimeout).send();
-    await collection.methods.setCollectionLimit('ownerCanTransfer', limits.ownerCanTransfer).send();
-    await collection.methods.setCollectionLimit('ownerCanDestroy', limits.ownerCanDestroy).send();
-    await collection.methods.setCollectionLimit('transfersEnabled', limits.transfersEnabled).send();
-    
-    const data = (await helper.rft.getData(collectionId))!;
-    expect(data.raw.limits.accountTokenOwnershipLimit).to.be.eq(expectedLimits.accountTokenOwnershipLimit);
-    expect(data.raw.limits.sponsoredDataSize).to.be.eq(expectedLimits.sponsoredDataSize);
-    expect(data.raw.limits.sponsoredDataRateLimit.blocks).to.be.eq(expectedLimits.sponsoredDataRateLimit);
-    expect(data.raw.limits.tokenLimit).to.be.eq(expectedLimits.tokenLimit);
-    expect(data.raw.limits.sponsorTransferTimeout).to.be.eq(expectedLimits.sponsorTransferTimeout);
-    expect(data.raw.limits.sponsorApproveTimeout).to.be.eq(expectedLimits.sponsorApproveTimeout);
-    expect(data.raw.limits.ownerCanTransfer).to.be.eq(expectedLimits.ownerCanTransfer);
-    expect(data.raw.limits.ownerCanDestroy).to.be.eq(expectedLimits.ownerCanDestroy);
-    expect(data.raw.limits.transfersEnabled).to.be.eq(expectedLimits.transfersEnabled);
-  });
-
   itEth('Collection address exist', async ({helper}) => {
     const owner = await helper.eth.createAccountWithBalance(donor);
     const collectionAddressForNonexistentCollection = '0x17C4E6453CC49AAAAEACA894E6D9683E00112233';
@@ -274,31 +224,5 @@
         .setCollectionLimit('account_token_ownership_limit', '1000')
         .call()).to.be.rejectedWith(EXPECTED_ERROR);
     }
-  });
-
-  itEth('(!negative test!) Set limits', async ({helper}) => {
-
-    const invalidLimits = {
-      accountTokenOwnershipLimit: BigInt(Number.MAX_SAFE_INTEGER),
-      transfersEnabled: 3,
-    };
-
-    const owner = await helper.eth.createAccountWithBalance(donor);
-    const {collectionAddress} = await helper.eth.createFungibleCollection(owner, 'Limits', DECIMALS, 'absolutely anything', 'ISNI');
-    const collectionEvm = helper.ethNativeContract.collection(collectionAddress, 'ft', owner);
-    await expect(collectionEvm.methods
-      .setCollectionLimit('badLimit', '1')
-      .call()).to.be.rejectedWith('unknown limit "badLimit"');
-    
-    await expect(collectionEvm.methods
-      .setCollectionLimit(Object.keys(invalidLimits)[0], invalidLimits.accountTokenOwnershipLimit)
-      .call()).to.be.rejectedWith(`can't convert value to u32 "${invalidLimits.accountTokenOwnershipLimit}"`);
-    
-    await expect(collectionEvm.methods
-      .setCollectionLimit(Object.keys(invalidLimits)[1], invalidLimits.transfersEnabled)
-      .call()).to.be.rejectedWith(`can't convert value to boolean "${invalidLimits.transfersEnabled}"`);
-  });
-
-   
-    
+  });    
 });

--- a/tests/src/eth/createNFTCollection.test.ts
+++ b/tests/src/eth/createNFTCollection.test.ts
@@ -120,56 +120,6 @@
     expect(await sponsorCollection.methods.description().call()).to.deep.equal(description);
   });
 
-  itEth('Set limits', async ({helper}) => {
-    const owner = await helper.eth.createAccountWithBalance(donor);
-    const {collectionId, collectionAddress} = await helper.eth.createNFTCollection(owner, 'Limits', 'absolutely anything', 'FLO');
-    const limits = {
-      accountTokenOwnershipLimit: 1000,
-      sponsoredDataSize: 1024,
-      sponsoredDataRateLimit: 30,
-      tokenLimit: 1000000,
-      sponsorTransferTimeout: 6,
-      sponsorApproveTimeout: 6,
-      ownerCanTransfer: 0,
-      ownerCanDestroy: 0,
-      transfersEnabled: 0,
-    };
-    
-    const expectedLimits = {
-      accountTokenOwnershipLimit: 1000,
-      sponsoredDataSize: 1024,
-      sponsoredDataRateLimit: 30,
-      tokenLimit: 1000000,
-      sponsorTransferTimeout: 6,
-      sponsorApproveTimeout: 6,
-      ownerCanTransfer: false,
-      ownerCanDestroy: false,
-      transfersEnabled: false,
-    };
-
-    const collection = helper.ethNativeContract.collection(collectionAddress, 'nft', owner);
-    await collection.methods.setCollectionLimit('accountTokenOwnershipLimit', limits.accountTokenOwnershipLimit).send();
-    await collection.methods.setCollectionLimit('sponsoredDataSize', limits.sponsoredDataSize).send();
-    await collection.methods.setCollectionLimit('sponsoredDataRateLimit', limits.sponsoredDataRateLimit).send();
-    await collection.methods.setCollectionLimit('tokenLimit', limits.tokenLimit).send();
-    await collection.methods.setCollectionLimit('sponsorTransferTimeout', limits.sponsorTransferTimeout).send();
-    await collection.methods.setCollectionLimit('sponsorApproveTimeout', limits.sponsorApproveTimeout).send();
-    await collection.methods.setCollectionLimit('ownerCanTransfer', limits.ownerCanTransfer).send();
-    await collection.methods.setCollectionLimit('ownerCanDestroy', limits.ownerCanDestroy).send();
-    await collection.methods.setCollectionLimit('transfersEnabled', limits.transfersEnabled).send();
-
-    const data = (await helper.rft.getData(collectionId))!;
-    expect(data.raw.limits.accountTokenOwnershipLimit).to.be.eq(expectedLimits.accountTokenOwnershipLimit);
-    expect(data.raw.limits.sponsoredDataSize).to.be.eq(expectedLimits.sponsoredDataSize);
-    expect(data.raw.limits.sponsoredDataRateLimit.blocks).to.be.eq(expectedLimits.sponsoredDataRateLimit);
-    expect(data.raw.limits.tokenLimit).to.be.eq(expectedLimits.tokenLimit);
-    expect(data.raw.limits.sponsorTransferTimeout).to.be.eq(expectedLimits.sponsorTransferTimeout);
-    expect(data.raw.limits.sponsorApproveTimeout).to.be.eq(expectedLimits.sponsorApproveTimeout);
-    expect(data.raw.limits.ownerCanTransfer).to.be.eq(expectedLimits.ownerCanTransfer);
-    expect(data.raw.limits.ownerCanDestroy).to.be.eq(expectedLimits.ownerCanDestroy);
-    expect(data.raw.limits.transfersEnabled).to.be.eq(expectedLimits.transfersEnabled);
-  });
-
   itEth('Collection address exist', async ({helper}) => {
     const owner = await helper.eth.createAccountWithBalance(donor);
     const collectionAddressForNonexistentCollection = '0x17C4E6453CC49AAAAEACA894E6D9683E00112233';
@@ -285,25 +235,6 @@
         .setCollectionLimit('account_token_ownership_limit', '1000')
         .call()).to.be.rejectedWith(EXPECTED_ERROR);
     }
-  });
-
-  itEth('(!negative test!) Set limits', async ({helper}) => {
-    const invalidLimits = {
-      accountTokenOwnershipLimit: BigInt(Number.MAX_SAFE_INTEGER),
-      transfersEnabled: 3,
-    };
-
-    const owner = await helper.eth.createAccountWithBalance(donor);
-    const {collectionAddress} = await helper.eth.createNFTCollection(owner, 'Limits', 'absolutely anything', 'OLF');
-    const collectionEvm = helper.ethNativeContract.collection(collectionAddress, 'nft', owner);
-    
-    await expect(collectionEvm.methods
-      .setCollectionLimit(Object.keys(invalidLimits)[0], invalidLimits.accountTokenOwnershipLimit)
-      .call()).to.be.rejectedWith(`can't convert value to u32 "${invalidLimits.accountTokenOwnershipLimit}"`);
-    
-    await expect(collectionEvm.methods
-      .setCollectionLimit(Object.keys(invalidLimits)[1], invalidLimits.transfersEnabled)
-      .call()).to.be.rejectedWith(`can't convert value to boolean "${invalidLimits.transfersEnabled}"`);
   });
 
   itEth('destroyCollection', async ({helper}) => {

--- a/tests/src/eth/createRFTCollection.test.ts
+++ b/tests/src/eth/createRFTCollection.test.ts
@@ -152,56 +152,6 @@
     expect(data.raw.sponsorship.Confirmed).to.be.equal(evmToAddress(sponsor, Number(ss58Format)));
   });
 
-  itEth('Set limits', async ({helper}) => {
-    const owner = await helper.eth.createAccountWithBalance(donor);
-    const {collectionId, collectionAddress} = await helper.eth.createRFTCollection(owner, 'Limits', 'absolutely anything', 'INSI');
-    const limits = {
-      accountTokenOwnershipLimit: 1000,
-      sponsoredDataSize: 1024,
-      sponsoredDataRateLimit: 30,
-      tokenLimit: 1000000,
-      sponsorTransferTimeout: 6,
-      sponsorApproveTimeout: 6,
-      ownerCanTransfer: 0,
-      ownerCanDestroy: 0,
-      transfersEnabled: 0,
-    };
-    
-    const expectedLimits = {
-      accountTokenOwnershipLimit: 1000,
-      sponsoredDataSize: 1024,
-      sponsoredDataRateLimit: 30,
-      tokenLimit: 1000000,
-      sponsorTransferTimeout: 6,
-      sponsorApproveTimeout: 6,
-      ownerCanTransfer: false,
-      ownerCanDestroy: false,
-      transfersEnabled: false,
-    };
-    
-    const collection = helper.ethNativeContract.collection(collectionAddress, 'rft', owner);
-    await collection.methods.setCollectionLimit('accountTokenOwnershipLimit', limits.accountTokenOwnershipLimit).send();
-    await collection.methods.setCollectionLimit('sponsoredDataSize', limits.sponsoredDataSize).send();
-    await collection.methods.setCollectionLimit('sponsoredDataRateLimit', limits.sponsoredDataRateLimit).send();
-    await collection.methods.setCollectionLimit('tokenLimit', limits.tokenLimit).send();
-    await collection.methods.setCollectionLimit('sponsorTransferTimeout', limits.sponsorTransferTimeout).send();
-    await collection.methods.setCollectionLimit('sponsorApproveTimeout', limits.sponsorApproveTimeout).send();
-    await collection.methods.setCollectionLimit('ownerCanTransfer', limits.ownerCanTransfer).send();
-    await collection.methods.setCollectionLimit('ownerCanDestroy', limits.ownerCanDestroy).send();
-    await collection.methods.setCollectionLimit('transfersEnabled', limits.transfersEnabled).send();
-    
-    const data = (await helper.rft.getData(collectionId))!;
-    expect(data.raw.limits.accountTokenOwnershipLimit).to.be.eq(expectedLimits.accountTokenOwnershipLimit);
-    expect(data.raw.limits.sponsoredDataSize).to.be.eq(expectedLimits.sponsoredDataSize);
-    expect(data.raw.limits.sponsoredDataRateLimit.blocks).to.be.eq(expectedLimits.sponsoredDataRateLimit);
-    expect(data.raw.limits.tokenLimit).to.be.eq(expectedLimits.tokenLimit);
-    expect(data.raw.limits.sponsorTransferTimeout).to.be.eq(expectedLimits.sponsorTransferTimeout);
-    expect(data.raw.limits.sponsorApproveTimeout).to.be.eq(expectedLimits.sponsorApproveTimeout);
-    expect(data.raw.limits.ownerCanTransfer).to.be.eq(expectedLimits.ownerCanTransfer);
-    expect(data.raw.limits.ownerCanDestroy).to.be.eq(expectedLimits.ownerCanDestroy);
-    expect(data.raw.limits.transfersEnabled).to.be.eq(expectedLimits.transfersEnabled);
-  });
-
   itEth('Collection address exist', async ({helper}) => {
     const owner = await helper.eth.createAccountWithBalance(donor);
     const collectionAddressForNonexistentCollection = '0x17C4E6453CC49AAAAEACA894E6D9683E00112233';
@@ -317,25 +267,6 @@
         .setCollectionLimit('account_token_ownership_limit', '1000')
         .call()).to.be.rejectedWith(EXPECTED_ERROR);
     }
-  });
-
-  itEth('(!negative test!) Set limits', async ({helper}) => {
-    const invalidLimits = {
-      accountTokenOwnershipLimit: BigInt(Number.MAX_SAFE_INTEGER),
-      transfersEnabled: 3,
-    };
-
-    const owner = await helper.eth.createAccountWithBalance(donor);
-    const {collectionAddress} = await helper.eth.createRFTCollection(owner, 'Limits', 'absolutely anything', 'ISNI');
-    const collectionEvm = helper.ethNativeContract.collection(collectionAddress, 'rft', owner);
-    
-    await expect(collectionEvm.methods
-      .setCollectionLimit(Object.keys(invalidLimits)[0], invalidLimits.accountTokenOwnershipLimit)
-      .call()).to.be.rejectedWith(`can't convert value to u32 "${invalidLimits.accountTokenOwnershipLimit}"`);
-    
-    await expect(collectionEvm.methods
-      .setCollectionLimit(Object.keys(invalidLimits)[1], invalidLimits.transfersEnabled)
-      .call()).to.be.rejectedWith(`can't convert value to boolean "${invalidLimits.transfersEnabled}"`);
   });
   
   itEth('destroyCollection', async ({helper}) => {

--- a/tests/src/eth/tokenProperties.test.ts
+++ b/tests/src/eth/tokenProperties.test.ts
@@ -49,52 +49,44 @@
     }
   });
 
-  itEth('Can be set', async({helper}) => {
-    const caller = await helper.eth.createAccountWithBalance(donor);
-    const collection = await helper.nft.mintCollection(alice, {
-      tokenPropertyPermissions: [{
-        key: 'testKey',
-        permission: {
-          collectionAdmin: true,
-        },
-      }],
-    });
-    const token = await collection.mintToken(alice);
+  [
+    {
+      method: 'setProperties',
+      methodParams: [[{key: 'testKey1', value: Buffer.from('testValue1')}, {key: 'testKey2', value: Buffer.from('testValue2')}]],
+      expectedProps: [{key: 'testKey1', value: 'testValue1'}, {key: 'testKey2', value: 'testValue2'}],
+    },
+    {
+      method: 'setProperty' /*Soft-deprecated*/, 
+      methodParams: ['testKey1', Buffer.from('testValue1')],
+      expectedProps: [{key: 'testKey1', value: 'testValue1'}],
+    },
+  ].map(testCase => 
+    itEth(`[${testCase.method}] Can be set`, async({helper}) => {
+      const caller = await helper.eth.createAccountWithBalance(donor);
+      const collection = await helper.nft.mintCollection(alice, {
+        tokenPropertyPermissions: [{
+          key: 'testKey1',
+          permission: {
+            collectionAdmin: true,
+          },
+        }, {
+          key: 'testKey2',
+          permission: {
+            collectionAdmin: true,
+          },
+        }],
+      });
 
-    await collection.addAdmin(alice, {Ethereum: caller});
-
-    const address = helper.ethAddress.fromCollectionId(collection.collectionId);
-    const contract = helper.ethNativeContract.collection(address, 'nft', caller);
-
-    await contract.methods.setProperties(token.tokenId, [{key: 'testKey', value: Buffer.from('testValue')}]).send({from: caller});
-
-    const [{value}] = await token.getProperties(['testKey']);
-    expect(value).to.equal('testValue');
-  });
-
-  // Soft-deprecated
-  itEth('Property can be set', async({helper}) => {
-    const caller = await helper.eth.createAccountWithBalance(donor);
-    const collection = await helper.nft.mintCollection(alice, {
-      tokenPropertyPermissions: [{
-        key: 'testKey',
-        permission: {
-          collectionAdmin: true,
-        },
-      }],
-    });
-    const token = await collection.mintToken(alice);
-
-    await collection.addAdmin(alice, {Ethereum: caller});
-
-    const address = helper.ethAddress.fromCollectionId(collection.collectionId);
-    const contract = helper.ethNativeContract.collection(address, 'nft', caller, true);
-
-    await contract.methods.setProperty(token.tokenId, 'testKey', Buffer.from('testValue')).send({from: caller});
-
-    const [{value}] = await token.getProperties(['testKey']);
-    expect(value).to.equal('testValue');
-  });
+      await collection.addAdmin(alice, {Ethereum: caller});
+      const token = await collection.mintToken(alice);
+  
+      const collectionEvm = helper.ethNativeContract.collectionById(collection.collectionId, 'nft', caller, testCase.method === 'setProperty');
+  
+      await collectionEvm.methods[testCase.method](token.tokenId, ...testCase.methodParams).send({from: caller});
+  
+      const properties = await token.getProperties();
+      expect(properties).to.deep.equal(testCase.expectedProps);
+    }));
   
   async function checkProps(helper: EthUniqueHelper, mode: TCollectionMode) {
     const caller = await helper.eth.createAccountWithBalance(donor);

--- a/tests/src/eth/util/playgrounds/unique.dev.ts
+++ b/tests/src/eth/util/playgrounds/unique.dev.ts
@@ -129,8 +129,8 @@
     return new web3.eth.Contract(abi as any, address, {gas: this.helper.eth.DEFAULT_GAS, ...(caller ? {from: caller} : {})});
   }
 
-  collectionById(collectionId: number, mode: 'nft' | 'rft' | 'ft', caller?: string): Contract {
-    return this.collection(this.helper.ethAddress.fromCollectionId(collectionId), mode, caller);
+  collectionById(collectionId: number, mode: 'nft' | 'rft' | 'ft', caller?: string, mergeDeprecated = false): Contract {
+    return this.collection(this.helper.ethAddress.fromCollectionId(collectionId), mode, caller, mergeDeprecated);
   }
 
   rftToken(address: string, caller?: string): Contract {