git.delta.rocks / unique-network / refs/commits / 3e8db543c726

--- a/.env
+++ b/.env
@@ -3,21 +3,21 @@
 
 POLKADOT_MAINNET_BRANCH=release-v0.9.30
 STATEMINT_BUILD_BRANCH=release-parachains-v9320
-ACALA_BUILD_BRANCH=2.10.1
+ACALA_BUILD_BRANCH=2.11.0
 MOONBEAM_BUILD_BRANCH=runtime-1901
-UNIQUE_MAINNET_BRANCH=v930033
+UNIQUE_MAINNET_BRANCH=release-v930033
 UNIQUE_REPLICA_FROM=wss://eu-ws.unique.network:443
 
-KUSAMA_MAINNET_BRANCH=release-v0.9.34
-STATEMINE_BUILD_BRANCH=release-parachains-v9320
-KARURA_BUILD_BRANCH=release-karura-2.10.0
-MOONRIVER_BUILD_BRANCH=runtime-1901
-QUARTZ_MAINNET_BRANCH=v930033
+KUSAMA_MAINNET_BRANCH=release-v0.9.35
+STATEMINE_BUILD_BRANCH=release-parachains-v9330
+KARURA_BUILD_BRANCH=release-karura-2.11.0
+MOONRIVER_BUILD_BRANCH=runtime-2000
+QUARTZ_MAINNET_BRANCH=release-v930034
 QUARTZ_REPLICA_FROM=wss://eu-ws-quartz.unique.network:443
 
 UNQWND_MAINNET_BRANCH=release-v0.9.30
 WESTMINT_BUILD_BRANCH=parachains-v9330
-OPAL_MAINNET_BRANCH=v930032
+OPAL_MAINNET_BRANCH=release-v930034
 OPAL_REPLICA_FROM=wss://eu-ws-opal.unique.network:443
 
 POLKADOT_LAUNCH_BRANCH=unique-network

--- a/tests/package.json
+++ b/tests/package.json
@@ -8,11 +8,13 @@
     "@types/chai": "^4.3.3",
     "@types/chai-as-promised": "^7.1.5",
     "@types/chai-like": "^1.1.1",
+    "@types/chai-subset": "^1.3.3",
     "@types/mocha": "^10.0.0",
     "@types/node": "^18.11.2",
     "@typescript-eslint/eslint-plugin": "^5.40.1",
     "@typescript-eslint/parser": "^5.40.1",
     "chai": "^4.3.6",
+    "chai-subset": "^1.6.0",
     "eslint": "^8.25.0",
     "eslint-plugin-mocha": "^10.1.0",
     "mocha": "^10.1.0",

--- a/tests/src/eth/collectionAdmin.test.ts
+++ b/tests/src/eth/collectionAdmin.test.ts
@@ -15,6 +15,7 @@
 
 import {IKeyringPair} from '@polkadot/types/types';
 import {expect} from 'chai';
+import {Pallets} from '../util';
 import {IEthCrossAccountId} from '../util/playgrounds/types';
 import {usingEthPlaygrounds, itEth} from './util';
 import {EthUniqueHelper} from './util/playgrounds/unique.dev';
@@ -39,36 +40,52 @@
     });
   });
 
-  itEth('can add account admin by owner', async ({helper, privateKey}) => {
-    // arrange
-    const owner = await helper.eth.createAccountWithBalance(donor);
-    const adminSub = await privateKey('//admin2');
-    const adminEth = helper.eth.createAccount().toLowerCase();
-
-    const adminDeprecated = helper.eth.createAccount().toLowerCase();
-    const adminCrossSub = helper.ethCrossAccount.fromKeyringPair(adminSub);
-    const adminCrossEth = helper.ethCrossAccount.fromAddress(adminEth);
-        
-    const {collectionAddress, collectionId} = await helper.eth.createNFTCollection(owner, 'A', 'B', 'C');
-    const collectionEvm = helper.ethNativeContract.collection(collectionAddress, 'nft', owner, true);
-
-    // Soft-deprecated: can addCollectionAdmin 
-    await collectionEvm.methods.addCollectionAdmin(adminDeprecated).send();
-    // Can addCollectionAdminCross for substrate and ethereum address
-    await collectionEvm.methods.addCollectionAdminCross(adminCrossSub).send();
-    await collectionEvm.methods.addCollectionAdminCross(adminCrossEth).send();
+  [
+    {mode: 'nft' as const, requiredPallets: []},
+    {mode: 'rft' as const, requiredPallets: [Pallets.ReFungible]},
+    {mode: 'ft' as const, requiredPallets: []},
+  ].map(testCase => {
+    itEth.ifWithPallets(`can add account admin by owner for ${testCase.mode}`, testCase.requiredPallets, async ({helper, privateKey}) => {
+      // arrange
+      const owner = await helper.eth.createAccountWithBalance(donor);
+      const adminSub = await privateKey('//admin2');
+      const adminEth = helper.eth.createAccount().toLowerCase();
+  
+      const adminDeprecated = helper.eth.createAccount().toLowerCase();
+      const adminCrossSub = helper.ethCrossAccount.fromKeyringPair(adminSub);
+      const adminCrossEth = helper.ethCrossAccount.fromAddress(adminEth);
+      
+      const {collectionAddress, collectionId} = await helper.eth.createCollection(testCase.mode, owner, 'A', 'B', 'C');
+      const collectionEvm = helper.ethNativeContract.collection(collectionAddress, testCase.mode, owner, true);
 
-    // 1. Expect api.rpc.unique.adminlist returns admins:
-    const adminListRpc = await helper.collection.getAdmins(collectionId);
-    expect(adminListRpc).to.has.length(3);
-    expect(adminListRpc).to.be.deep.contain.members([{Substrate: adminSub.address}, {Ethereum: adminEth}, {Ethereum: adminDeprecated}]);
+      // Check isOwnerOrAdminCross returns false:
+      expect(await collectionEvm.methods.isOwnerOrAdminCross(adminCrossSub).call()).to.be.false;
+      expect(await collectionEvm.methods.isOwnerOrAdminCross(adminCrossEth).call()).to.be.false;
+      expect(await collectionEvm.methods.isOwnerOrAdminCross(helper.ethCrossAccount.fromAddress(adminDeprecated)).call()).to.be.false;
+      
+      // Soft-deprecated: can addCollectionAdmin 
+      await collectionEvm.methods.addCollectionAdmin(adminDeprecated).send();
+      // Can addCollectionAdminCross for substrate and ethereum address
+      await collectionEvm.methods.addCollectionAdminCross(adminCrossSub).send();
+      await collectionEvm.methods.addCollectionAdminCross(adminCrossEth).send();
+  
+      // 1. Expect api.rpc.unique.adminlist returns admins:
+      const adminListRpc = await helper.collection.getAdmins(collectionId);
+      expect(adminListRpc).to.has.length(3);
+      expect(adminListRpc).to.be.deep.contain.members([{Substrate: adminSub.address}, {Ethereum: adminEth}, {Ethereum: adminDeprecated}]);
+  
+      // 2. Expect methods.collectionAdmins == api.rpc.unique.adminlist
+      let adminListEth = await collectionEvm.methods.collectionAdmins().call();
+      adminListEth = adminListEth.map((element: IEthCrossAccountId) => {
+        return helper.address.convertCrossAccountFromEthCrossAccount(element);
+      });
+      expect(adminListRpc).to.be.like(adminListEth);
 
-    // 2. Expect methods.collectionAdmins == api.rpc.unique.adminlist
-    let adminListEth = await collectionEvm.methods.collectionAdmins().call();
-    adminListEth = adminListEth.map((element: IEthCrossAccountId) => {
-      return helper.address.convertCrossAccountFromEthCrossAccount(element);
+      // 3. check isOwnerOrAdminCross returns true:
+      expect(await collectionEvm.methods.isOwnerOrAdminCross(adminCrossSub).call()).to.be.true;
+      expect(await collectionEvm.methods.isOwnerOrAdminCross(adminCrossEth).call()).to.be.true;
+      expect(await collectionEvm.methods.isOwnerOrAdminCross(helper.ethCrossAccount.fromAddress(adminDeprecated)).call()).to.be.true;
     });
-    expect(adminListRpc).to.be.like(adminListEth);
   });
 
   itEth('cross account admin can mint', async ({helper}) => {

--- a/tests/src/eth/collectionProperties.test.ts
+++ b/tests/src/eth/collectionProperties.test.ts
@@ -26,27 +26,36 @@
   before(async function() {
     await usingEthPlaygrounds(async (_helper, privateKey) => {
       donor = await privateKey({filename: __filename});
-      [alice] = await _helper.arrange.createAccounts([20n], donor);
+      [alice] = await _helper.arrange.createAccounts([50n], donor);
     });
   });
 
   // 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'}]},
+    {method: 'setCollectionProperties', mode: 'nft' as const, methodParams: [[{key: 'testKey1', value: Buffer.from('testValue1')}, {key: 'testKey2', value: Buffer.from('testValue2')}]], expectedProps: [{key: 'testKey1', value: 'testValue1'}, {key: 'testKey2', value: 'testValue2'}]}, 
+    {method: 'setCollectionProperties', mode: 'rft' as const, methodParams: [[{key: 'testKey1', value: Buffer.from('testValue1')}, {key: 'testKey2', value: Buffer.from('testValue2')}]], expectedProps: [{key: 'testKey1', value: 'testValue1'}, {key: 'testKey2', value: 'testValue2'}]}, 
+    {method: 'setCollectionProperties', mode: 'ft' as const, methodParams: [[{key: 'testKey1', value: Buffer.from('testValue1')}, {key: 'testKey2', value: Buffer.from('testValue2')}]], expectedProps: [{key: 'testKey1', value: 'testValue1'}, {key: 'testKey2', value: 'testValue2'}]}, 
+    {method: 'setCollectionProperty', mode: 'nft' as const, methodParams: ['testKey', Buffer.from('testValue')], expectedProps: [{key: 'testKey', value: 'testValue'}]},
   ].map(testCase => 
-    itEth(`Collection properties can be set: ${testCase.method}`, async({helper}) => {
+    itEth.ifWithPallets(`Collection properties can be set: ${testCase.method}() for ${testCase.mode}`, testCase.mode === 'rft' ? [Pallets.ReFungible] : [], async({helper}) => {
       const caller = await helper.eth.createAccountWithBalance(donor);
-      const collection = await helper.nft.mintCollection(alice, {name: 'name', description: 'test', tokenPrefix: 'test', properties: []});
+      const collection = await helper[testCase.mode].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');
+      const collectionEvm = helper.ethNativeContract.collection(address, 'nft', caller, testCase.method === 'setCollectionProperty');
 
-      await contract.methods[testCase.method](...testCase.methodParams).send({from: caller});
+      // collectionProperties returns an empty array if no properties: 
+      expect(await collectionEvm.methods.collectionProperties([]).call()).to.be.like([]);
+      expect(await collectionEvm.methods.collectionProperties(['NonExistingKey']).call()).to.be.like([]);
+
+      await collectionEvm.methods[testCase.method](...testCase.methodParams).send({from: caller});
 
       const raw = (await collection.getData())?.raw;
       expect(raw.properties).to.deep.equal(testCase.expectedProps);
+
+      // collectionProperties returns properties: 
+      expect(await collectionEvm.methods.collectionProperties([]).call()).to.be.like(testCase.expectedProps.map(prop => helper.ethProperty.property(prop.key, prop.value)));
     }));
 
   itEth('Cannot set invalid properties', async({helper}) => {
@@ -68,16 +77,18 @@
 
   // 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'}]}, 
+    {method: 'deleteCollectionProperties', mode: 'nft' as const, methodParams: [['testKey1', 'testKey2']], expectedProps: [{key: 'testKey3', value: 'testValue3'}]},
+    {method: 'deleteCollectionProperties', mode: 'rft' as const, methodParams: [['testKey1', 'testKey2']], expectedProps: [{key: 'testKey3', value: 'testValue3'}]},
+    {method: 'deleteCollectionProperties', mode: 'ft' as const, methodParams: [['testKey1', 'testKey2']], expectedProps: [{key: 'testKey3', value: 'testValue3'}]},
+    {method: 'deleteCollectionProperty', mode: 'nft' as const, methodParams: ['testKey1'], expectedProps: [{key: 'testKey2', value: 'testValue2'}, {key: 'testKey3', value: 'testValue3'}]}, 
   ].map(testCase => 
-    itEth(`Collection properties can be deleted: ${testCase.method}()`, async({helper}) => {
+    itEth.ifWithPallets(`Collection properties can be deleted: ${testCase.method}() for ${testCase.mode}`, testCase.mode === 'rft' ? [Pallets.ReFungible] : [], 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});
+      const collection = await helper[testCase.mode].mintCollection(alice, {name: 'name', description: 'test', tokenPrefix: 'test', properties});
   
       await collection.addAdmin(alice, {Ethereum: caller});
   
@@ -92,7 +103,6 @@
       expect(raw.properties).to.deep.equal(testCase.expectedProps);
     }));
 
-  
   [
     {method: 'deleteCollectionProperties', methodParams: [['testKey2']]},
     {method: 'deleteCollectionProperty', methodParams: ['testKey2']},
@@ -207,82 +217,5 @@
   
       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', () => {
-  let donor: IKeyringPair;
-
-  before(async function() {
-    await usingEthPlaygrounds(async (_helper, privateKey) => {
-      donor = await privateKey({filename: __filename});
-    });
-  });
-
-  [
-    {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 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'),
-      ];
-  
-      await contract.methods.setCollectionProperties(writeProperties).send();
-      const readProperties = await contract.methods.collectionProperties([keys[0], keys[1]]).call();
-      expect(readProperties).to.be.like(writeProperties);
-    }));
-
-  [
-    {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'});
-
-      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', '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);
-      }
     }));
 });

--- a/tests/src/eth/contractSponsoring.test.ts
+++ b/tests/src/eth/contractSponsoring.test.ts
@@ -22,29 +22,31 @@
 
 describe('Sponsoring EVM contracts', () => {
   let donor: IKeyringPair;
+  let nominal: bigint;
 
   before(async () => {
-    await usingPlaygrounds(async (_helper, privateKey) => {
+    await usingPlaygrounds(async (helper, privateKey) => {
       donor = await privateKey({filename: __filename});
+      nominal = helper.balance.getOneTokenNominal();
     });
   });
 
-  itEth('Self sponsored can be set by the address that deployed the contract', async ({helper}) => {
+  itEth('Self sponsoring can be set by the address that deployed the contract', async ({helper}) => {
     const owner = await helper.eth.createAccountWithBalance(donor);
     const flipper = await helper.eth.deployFlipper(owner);
     const helpers = helper.ethNativeContract.contractHelpers(owner);
 
+    // 1. owner can set selfSponsoring:
     expect(await helpers.methods.hasSponsor(flipper.options.address).call()).to.be.false;
-    await expect(helpers.methods.selfSponsoredEnable(flipper.options.address).send()).to.be.not.rejected;
+    const result = await helpers.methods.selfSponsoredEnable(flipper.options.address).send({from: owner});
     expect(await helpers.methods.hasSponsor(flipper.options.address).call()).to.be.true;
-  });
 
-  itEth('Set self sponsored events', async ({helper}) => {
-    const owner = await helper.eth.createAccountWithBalance(donor);
-    const flipper = await helper.eth.deployFlipper(owner);
-    const helpers = helper.ethNativeContract.contractHelpers(owner);
-    
-    const result = await helpers.methods.selfSponsoredEnable(flipper.options.address).send();
+    // 1.1 Can get sponsor using methods.sponsor:
+    const actualSponsor = await helpers.methods.sponsor(flipper.options.address).call();
+    expect(actualSponsor.eth).to.eq(flipper.options.address);
+    expect(actualSponsor.sub).to.eq('0');
+
+    // 2. Events should be:
     const ethEvents = helper.eth.helper.eth.normalizeEvents(result.events);
     expect(ethEvents).to.be.deep.equal([
       {
@@ -66,7 +68,7 @@
     ]);
   });
 
-  itEth('Self sponsored can not be set by the address that did not deployed the contract', async ({helper}) => {
+  itEth('Self sponsoring cannot be set by the address that did not deployed the contract', async ({helper}) => {
     const owner = await helper.eth.createAccountWithBalance(donor);
     const notOwner = await helper.eth.createAccountWithBalance(donor);
     const helpers = helper.ethNativeContract.contractHelpers(owner);
@@ -83,7 +85,7 @@
     const flipper = await helper.eth.deployFlipper(owner);
 
     expect(await helpers.methods.sponsoringEnabled(flipper.options.address).call()).to.be.false;
-    await expect(helpers.methods.setSponsoringMode(flipper.options.address, SponsoringMode.Allowlisted).send({from: owner})).to.be.not.rejected;
+    await helpers.methods.setSponsoringMode(flipper.options.address, SponsoringMode.Allowlisted).send({from: owner});
     expect(await helpers.methods.sponsoringEnabled(flipper.options.address).call()).to.be.true;
   });
 
@@ -104,18 +106,12 @@
     const helpers = helper.ethNativeContract.contractHelpers(owner);
     const flipper = await helper.eth.deployFlipper(owner);
 
+    // 1. owner can set a sponsor:
     expect(await helpers.methods.hasPendingSponsor(flipper.options.address).call()).to.be.false;
-    await expect(helpers.methods.setSponsor(flipper.options.address, sponsor).send()).to.be.not.rejected;
-    expect(await helpers.methods.hasPendingSponsor(flipper.options.address).call()).to.be.true;
-  });
-  
-  itEth('Set sponsor event', async ({helper}) => {
-    const owner = await helper.eth.createAccountWithBalance(donor);
-    const sponsor = await helper.eth.createAccountWithBalance(donor);
-    const helpers = helper.ethNativeContract.contractHelpers(owner);
-    const flipper = await helper.eth.deployFlipper(owner);
-    
     const result = await helpers.methods.setSponsor(flipper.options.address, sponsor).send();
+    expect(await helpers.methods.hasPendingSponsor(flipper.options.address).call()).to.be.true;
+
+    // 2. Events should be:
     const events = helper.eth.normalizeEvents(result.events);
     expect(events).to.be.deep.equal([
       {
@@ -129,7 +125,7 @@
     ]);
   });
   
-  itEth('Sponsor can not be set by the address that did not deployed the contract', async ({helper}) => {
+  itEth('Sponsor cannot be set by the address that did not deployed the contract', async ({helper}) => {
     const owner = await helper.eth.createAccountWithBalance(donor);
     const sponsor = await helper.eth.createAccountWithBalance(donor);
     const notOwner = await helper.eth.createAccountWithBalance(donor);
@@ -148,19 +144,18 @@
     const flipper = await helper.eth.deployFlipper(owner);
 
     expect(await helpers.methods.hasSponsor(flipper.options.address).call()).to.be.false;
-    await expect(helpers.methods.setSponsor(flipper.options.address, sponsor).send()).to.be.not.rejected;
-    await expect(helpers.methods.confirmSponsorship(flipper.options.address).send({from: sponsor})).to.be.not.rejected;
+    await helpers.methods.setSponsor(flipper.options.address, sponsor).send();
+
+    // 1. sponsor can confirm sponsorship:
+    const result = await helpers.methods.confirmSponsorship(flipper.options.address).send({from: sponsor});
     expect(await helpers.methods.hasSponsor(flipper.options.address).call()).to.be.true;
-  });
 
-  itEth('Confirm sponsorship event', async ({helper}) => {
-    const owner = await helper.eth.createAccountWithBalance(donor);
-    const sponsor = await helper.eth.createAccountWithBalance(donor);
-    const helpers = helper.ethNativeContract.contractHelpers(owner);
-    const flipper = await helper.eth.deployFlipper(owner);
+    // 1.1 Can get sponsor using methods.sponsor:
+    const actualSponsor = await helpers.methods.sponsor(flipper.options.address).call();
+    expect(actualSponsor.eth).to.eq(sponsor);
+    expect(actualSponsor.sub).to.eq('0');
 
-    await expect(helpers.methods.setSponsor(flipper.options.address, sponsor).send()).to.be.not.rejected;
-    const result = await helpers.methods.confirmSponsorship(flipper.options.address).send({from: sponsor});
+    // 2. Events should be:
     const events = helper.eth.normalizeEvents(result.events);
     expect(events).to.be.deep.equal([
       {
@@ -196,34 +191,6 @@
     expect(await helpers.methods.hasSponsor(flipper.options.address).call()).to.be.false;
     await expect(helpers.methods.confirmSponsorship(flipper.options.address).call({from: notSponsor})).to.be.rejectedWith('NoPendingSponsor');
     expect(await helpers.methods.hasSponsor(flipper.options.address).call()).to.be.false;
-  });
-
-  itEth('Get self sponsored sponsor', async ({helper}) => {
-    const owner = await helper.eth.createAccountWithBalance(donor);
-    const helpers = helper.ethNativeContract.contractHelpers(owner);
-    const flipper = await helper.eth.deployFlipper(owner);
-
-    await helpers.methods.selfSponsoredEnable(flipper.options.address).send();
-    
-    const result = await helpers.methods.sponsor(flipper.options.address).call();
-
-    expect(result[0]).to.be.eq(flipper.options.address);
-    expect(result[1]).to.be.eq('0');
-  });
-
-  itEth('Get confirmed sponsor', async ({helper}) => {
-    const owner = await helper.eth.createAccountWithBalance(donor);
-    const sponsor = await helper.eth.createAccountWithBalance(donor);
-    const helpers = helper.ethNativeContract.contractHelpers(owner);
-    const flipper = await helper.eth.deployFlipper(owner);
-
-    await helpers.methods.setSponsor(flipper.options.address, sponsor).send();
-    await helpers.methods.confirmSponsorship(flipper.options.address).send({from: sponsor});
-    
-    const result = await helpers.methods.sponsor(flipper.options.address).call();
-
-    expect(result[0]).to.be.eq(sponsor);
-    expect(result[1]).to.be.eq('0');
   });
 
   itEth('Sponsor can be removed by the address that deployed the contract', async ({helper}) => {
@@ -236,21 +203,11 @@
     await helpers.methods.setSponsor(flipper.options.address, sponsor).send();
     await helpers.methods.confirmSponsorship(flipper.options.address).send({from: sponsor});
     expect(await helpers.methods.hasSponsor(flipper.options.address).call()).to.be.true;
-    
-    await helpers.methods.removeSponsor(flipper.options.address).send();
+    // 1. Can remove sponsor:
+    const result = await helpers.methods.removeSponsor(flipper.options.address).send();
     expect(await helpers.methods.hasSponsor(flipper.options.address).call()).to.be.false;
-  });
 
-  itEth('Remove sponsor event', async ({helper}) => {
-    const owner = await helper.eth.createAccountWithBalance(donor);
-    const sponsor = await helper.eth.createAccountWithBalance(donor);
-    const helpers = helper.ethNativeContract.contractHelpers(owner);
-    const flipper = await helper.eth.deployFlipper(owner);
-
-    await helpers.methods.setSponsor(flipper.options.address, sponsor).send();
-    await helpers.methods.confirmSponsorship(flipper.options.address).send({from: sponsor});
-    
-    const result = await helpers.methods.removeSponsor(flipper.options.address).send();
+    // 2. Events should be:
     const events = helper.eth.normalizeEvents(result.events);
     expect(events).to.be.deep.equal([
       {
@@ -261,6 +218,11 @@
         },
       },
     ]);
+
+    // TODO: why call method reverts?
+    // const actualSponsor = await helpers.methods.sponsor(flipper.options.address).call();
+    // expect(actualSponsor.eth).to.eq(sponsor);
+    // expect(actualSponsor.sub).to.eq('0');
   });
 
   itEth('Sponsor can not be removed by the address that did not deployed the contract', async ({helper}) => {
@@ -276,6 +238,7 @@
     expect(await helpers.methods.hasSponsor(flipper.options.address).call()).to.be.true;
     
     await expect(helpers.methods.removeSponsor(flipper.options.address).call({from: notOwner})).to.be.rejectedWith('NoPermission');
+    await expect(helpers.methods.removeSponsor(flipper.options.address).send({from: notOwner})).to.be.rejected;
     expect(await helpers.methods.hasSponsor(flipper.options.address).call()).to.be.true;
   });
 
@@ -292,15 +255,15 @@
     await helpers.methods.setSponsoringMode(flipper.options.address, SponsoringMode.Generous).send({from: owner});
     await helpers.methods.setSponsoringRateLimit(flipper.options.address, 0).send({from: owner});
 
-    const sponsorBalanceBefore = await helper.balance.getSubstrate(await helper.address.ethToSubstrate(sponsor));
-    const callerBalanceBefore = await helper.balance.getSubstrate(await helper.address.ethToSubstrate(caller));
+    const sponsorBalanceBefore = await helper.balance.getSubstrate(helper.address.ethToSubstrate(sponsor));
+    const callerBalanceBefore = await helper.balance.getSubstrate(helper.address.ethToSubstrate(caller));
 
     await flipper.methods.flip().send({from: caller});
     expect(await flipper.methods.getValue().call()).to.be.true;
 
     // Balance should be taken from sponsor instead of caller
-    const sponsorBalanceAfter = await helper.balance.getSubstrate(await helper.address.ethToSubstrate(sponsor));
-    const callerBalanceAfter = await helper.balance.getSubstrate(await helper.address.ethToSubstrate(caller));
+    const sponsorBalanceAfter = await helper.balance.getSubstrate(helper.address.ethToSubstrate(sponsor));
+    const callerBalanceAfter = await helper.balance.getSubstrate(helper.address.ethToSubstrate(caller));
     expect(sponsorBalanceAfter < sponsorBalanceBefore).to.be.true;
     expect(callerBalanceAfter).to.be.eq(callerBalanceBefore);
   });
@@ -331,82 +294,67 @@
     expect(callerBalanceAfter).to.be.eq(callerBalanceBefore);
   });
 
-  itEth('Sponsoring is set, an address that has no UNQ can send a transaction and it works. Sponsor balance should decrease (allowlisted)', async ({helper}) => {
-    const owner = await helper.eth.createAccountWithBalance(donor);
-    const sponsor = await helper.eth.createAccountWithBalance(donor);
-    const caller = helper.eth.createAccount();
-    const helpers = helper.ethNativeContract.contractHelpers(owner);
-    const flipper = await helper.eth.deployFlipper(owner);
-
-    await helpers.methods.toggleAllowlist(flipper.options.address, true).send({from: owner});
-    await helpers.methods.toggleAllowed(flipper.options.address, caller, true).send({from: owner});
-
-    await helpers.methods.setSponsoringMode(flipper.options.address, SponsoringMode.Allowlisted).send({from: owner});
-    await helpers.methods.setSponsoringRateLimit(flipper.options.address, 0).send({from: owner});
-
-    await helpers.methods.setSponsor(flipper.options.address, sponsor).send();
-    await helpers.methods.confirmSponsorship(flipper.options.address).send({from: sponsor});
-
-    const sponsorBalanceBefore = await helper.balance.getSubstrate(await helper.address.ethToSubstrate(sponsor));
-    expect(sponsorBalanceBefore).to.be.not.equal('0');
-
-    await flipper.methods.flip().send({from: caller});
-    expect(await flipper.methods.getValue().call()).to.be.true;
-
-    // Balance should be taken from flipper instead of caller
-    const sponsorBalanceAfter = await helper.balance.getSubstrate(await helper.address.ethToSubstrate(sponsor));
-    expect(sponsorBalanceAfter < sponsorBalanceBefore).to.be.true;
+  [
+    {balance: 0n, label: '0'},
+    {balance: 10n, label: '10'},
+  ].map(testCase => {
+    itEth(`Allow-listed address that has ${testCase.label} UNQ can call a contract. Sponsor balance should decrease`, async ({helper}) => {
+      const owner = await helper.eth.createAccountWithBalance(donor);
+      const sponsor = await helper.eth.createAccountWithBalance(donor);
+      const caller = helper.eth.createAccount();
+      await helper.eth.transferBalanceFromSubstrate(donor, caller, testCase.balance);
+      const helpers = helper.ethNativeContract.contractHelpers(owner);
+      const flipper = await helper.eth.deployFlipper(owner);
+  
+      await helpers.methods.toggleAllowlist(flipper.options.address, true).send({from: owner});
+      await helpers.methods.toggleAllowed(flipper.options.address, caller, true).send({from: owner});
+  
+      await helpers.methods.setSponsoringMode(flipper.options.address, SponsoringMode.Allowlisted).send({from: owner});
+      await helpers.methods.setSponsoringRateLimit(flipper.options.address, 0).send({from: owner});
+  
+      await helpers.methods.setSponsor(flipper.options.address, sponsor).send();
+      await helpers.methods.confirmSponsorship(flipper.options.address).send({from: sponsor});
+  
+      const sponsorBalanceBefore = await helper.balance.getSubstrate(helper.address.ethToSubstrate(sponsor));
+      expect(sponsorBalanceBefore > 0n).to.be.true;
+  
+      await flipper.methods.flip().send({from: caller});
+      expect(await flipper.methods.getValue().call()).to.be.true;
+  
+      // Balance should be taken from flipper instead of caller
+      const sponsorBalanceAfter = await helper.balance.getSubstrate(helper.address.ethToSubstrate(sponsor));
+      expect(sponsorBalanceAfter < sponsorBalanceBefore).to.be.true;
+      // Caller's balance does not change:
+      const callerBalanceAfter = await helper.balance.getSubstrate(helper.address.ethToSubstrate(caller));
+      expect(callerBalanceAfter).to.eq(testCase.balance * nominal);
+    });
   });
 
-  itEth('Sponsoring is set, an address that has no UNQ can send a transaction and it works. Sponsor balance should not decrease (non-allowlisted)', async ({helper}) => {
+  itEth('Non-allow-listed address can call a contract. Sponsor balance should not decrease', async ({helper}) => {
     const owner = await helper.eth.createAccountWithBalance(donor);
-    const caller = await helper.eth.createAccount();
-    const helpers = helper.ethNativeContract.contractHelpers(owner);
-    const flipper = await helper.eth.deployFlipper(owner);
-
-    await helpers.methods.setSponsoringMode(flipper.options.address, SponsoringMode.Allowlisted).send({from: owner});
-    await helpers.methods.setSponsoringRateLimit(flipper.options.address, 0).send({from: owner});
+    const caller = helper.eth.createAccount();
+    const contractHelpers = helper.ethNativeContract.contractHelpers(owner);
 
+    // Deploy flipper and send some tokens:
+    const flipper = await helper.eth.deployFlipper(owner);
     await helper.eth.transferBalanceFromSubstrate(donor, flipper.options.address);
-
+    expect(await flipper.methods.getValue().call()).to.be.false;
+    // flipper address has some tokens:
     const originalFlipperBalance = await helper.balance.getEthereum(flipper.options.address);
-    expect(originalFlipperBalance).to.be.not.equal('0');
+    expect(originalFlipperBalance > 0n).to.be.true;
+
+    // Set Allowlisted sponsoring mode. caller is not in allow list:
+    await contractHelpers.methods.toggleAllowlist(flipper.options.address, true).send({from: owner});
+    await contractHelpers.methods.setSponsoringMode(flipper.options.address, SponsoringMode.Allowlisted).send({from: owner});
+    await contractHelpers.methods.setSponsoringRateLimit(flipper.options.address, 0).send({from: owner});
 
+    // 1. Caller has no UNQ and is not in allow list. So he cannot flip: 
     await expect(flipper.methods.flip().send({from: caller})).to.be.rejectedWith(/Returned error: insufficient funds for gas \* price \+ value/);
     expect(await flipper.methods.getValue().call()).to.be.false;
 
-    // Balance should be taken from flipper instead of caller
-    // FIXME the comment is wrong! What check should be here?
+    // Flipper's balance does not change:
     const balanceAfter = await helper.balance.getEthereum(flipper.options.address);
     expect(balanceAfter).to.be.equal(originalFlipperBalance);
-  });
-
-  itEth('Sponsoring is set, an address that has UNQ can send a transaction and it works. User balance should not change', async ({helper}) => {
-    const owner = await helper.eth.createAccountWithBalance(donor);
-    const sponsor = await helper.eth.createAccountWithBalance(donor);
-    const caller = await helper.eth.createAccountWithBalance(donor);
-    const helpers = helper.ethNativeContract.contractHelpers(owner);
-    const flipper = await helper.eth.deployFlipper(owner);
-
-    await helpers.methods.toggleAllowlist(flipper.options.address, true).send({from: owner});
-    await helpers.methods.toggleAllowed(flipper.options.address, caller, true).send({from: owner});
-
-    await helpers.methods.setSponsoringMode(flipper.options.address, SponsoringMode.Allowlisted).send({from: owner});
-    await helpers.methods.setSponsoringRateLimit(flipper.options.address, 0).send({from: owner});
-
-    await helpers.methods.setSponsor(flipper.options.address, sponsor).send();
-    await helpers.methods.confirmSponsorship(flipper.options.address).send({from: sponsor});
-
-    const sponsorBalanceBefore = await helper.balance.getSubstrate(await helper.address.ethToSubstrate(sponsor));
-    const callerBalanceBefore = await helper.balance.getSubstrate(await helper.address.ethToSubstrate(caller));
-
-    await flipper.methods.flip().send({from: caller});
-    expect(await flipper.methods.getValue().call()).to.be.true;
-
-    const sponsorBalanceAfter = await helper.balance.getSubstrate(await helper.address.ethToSubstrate(sponsor));
-    const callerBalanceAfter = await helper.balance.getSubstrate(await helper.address.ethToSubstrate(caller));
-    expect(sponsorBalanceAfter < sponsorBalanceBefore).to.be.true;
-    expect(callerBalanceAfter).to.be.equal(callerBalanceBefore);
   });
 
   itEth('Sponsoring is limited, with setContractRateLimit. The limitation is working if transactions are sent more often, the sender pays the commission.', async ({helper}) => {
@@ -427,7 +375,7 @@
     await helpers.methods.confirmSponsorship(flipper.options.address).send({from: sponsor});
 
     const originalFlipperBalance = await helper.balance.getEthereum(sponsor);
-    expect(originalFlipperBalance).to.be.not.equal('0');
+    expect(originalFlipperBalance > 0n).to.be.true;
 
     await flipper.methods.flip().send({from: caller});
     expect(await flipper.methods.getValue().call()).to.be.true;

40  const {collectionAddress, events: ethEvents} = await helper.eth.createCollection(mode, owner, 'A', 'B', 'C');40  const {collectionAddress, events: ethEvents} = await helper.eth.createCollection(mode, owner, 'A', 'B', 'C');
41  await helper.wait.newBlocks(1);41  await helper.wait.newBlocks(1);
42  {42  {
43    expect(ethEvents).to.be.like([43    expect(ethEvents).to.containSubset([
44      {44      {
45        event: 'CollectionCreated',45        event: 'CollectionCreated',
46        args: {46        args: {
49        },49        },
50      },50      },
51    ]);51    ]);
52    expect(subEvents).to.be.like([{method: 'CollectionCreated'}]);52    expect(subEvents).to.containSubset([{method: 'CollectionCreated'}]);
53    clearEvents(ethEvents, subEvents);53    clearEvents(ethEvents, subEvents);
54  }54  }
55  {55  {
56    const collectionHelper = helper.ethNativeContract.collectionHelpers(owner);56    const collectionHelper = helper.ethNativeContract.collectionHelpers(owner);
57    const result = await collectionHelper.methods.destroyCollection(collectionAddress).send({from:owner});57    const result = await collectionHelper.methods.destroyCollection(collectionAddress).send({from:owner});
58    await helper.wait.newBlocks(1);58    await helper.wait.newBlocks(1);
59    expect(result.events).to.be.like({59    expect(result.events).to.containSubset({
60      CollectionDestroyed: {60      CollectionDestroyed: {
61        returnValues: {61        returnValues: {
62          collectionId: collectionAddress,62          collectionId: collectionAddress,
63        },63        },
64      },64      },
65    });65    });
66    expect(subEvents).to.be.like([{method: 'CollectionDestroyed'}]);66    expect(subEvents).to.containSubset([{method: 'CollectionDestroyed'}]);
67  }67  }
68  unsubscribe();68  unsubscribe();
69}69}
7070
71async function testCollectionPropertySetAndDeleted(helper: EthUniqueHelper, mode: TCollectionMode) {71async function testCollectionPropertySetAndDeleted(helper: EthUniqueHelper, mode: TCollectionMode) {
72  const owner = await helper.eth.createAccountWithBalance(donor);72  const owner = await helper.eth.createAccountWithBalance(donor);
73  const {collectionAddress} = await helper.eth.createCollection(mode, owner, 'A', 'B', 'C');73  const {collectionAddress} = await helper.eth.createCollection(mode, owner, 'A', 'B', 'C');
74  const collection = await helper.ethNativeContract.collection(collectionAddress, mode, owner);74  const collection = helper.ethNativeContract.collection(collectionAddress, mode, owner);
75  const collectionHelper = helper.ethNativeContract.collectionHelpers(owner);75  const collectionHelper = helper.ethNativeContract.collectionHelpers(owner);
76    76    
77  const ethEvents: any = [];77  const ethEvents: any = [];
82  {82  {
83    await collection.methods.setCollectionProperties([{key: 'A', value: [0,1,2,3]}]).send({from:owner});83    await collection.methods.setCollectionProperties([{key: 'A', value: [0,1,2,3]}]).send({from:owner});
84    await helper.wait.newBlocks(1);84    await helper.wait.newBlocks(1);
85    expect(ethEvents).to.be.like([85    expect(ethEvents).to.containSubset([
86      {86      {
87        event: 'CollectionChanged',87        event: 'CollectionChanged',
88        returnValues: {88        returnValues: {
89          collectionId: collectionAddress,89          collectionId: collectionAddress,
90        },90        },
91      },91      },
92    ]);92    ]);
93    expect(subEvents).to.be.like([{method: 'CollectionPropertySet'}]);93    expect(subEvents).to.containSubset([{method: 'CollectionPropertySet'}]);
94    clearEvents(ethEvents, subEvents);94    clearEvents(ethEvents, subEvents);
95  }95  }
96  {96  {
97    await collection.methods.deleteCollectionProperties(['A']).send({from:owner});97    await collection.methods.deleteCollectionProperties(['A']).send({from:owner});
98    await helper.wait.newBlocks(1);98    await helper.wait.newBlocks(1);
99    expect(ethEvents).to.be.like([99    expect(ethEvents).to.containSubset([
100      {100      {
101        event: 'CollectionChanged',101        event: 'CollectionChanged',
102        returnValues: {102        returnValues: {
103          collectionId: collectionAddress,103          collectionId: collectionAddress,
104        },104        },
105      },105      },
106    ]);106    ]);
107    expect(subEvents).to.be.like([{method: 'CollectionPropertyDeleted'}]);107    expect(subEvents).to.containSubset([{method: 'CollectionPropertyDeleted'}]);
108  }108  }
109  unsubscribe();109  unsubscribe();
110}110}
111111
112async function testPropertyPermissionSet(helper: EthUniqueHelper, mode: TCollectionMode) {112async function testPropertyPermissionSet(helper: EthUniqueHelper, mode: TCollectionMode) {
113  const owner = await helper.eth.createAccountWithBalance(donor);113  const owner = await helper.eth.createAccountWithBalance(donor);
114  const {collectionAddress} = await helper.eth.createCollection(mode, owner, 'A', 'B', 'C');114  const {collectionAddress} = await helper.eth.createCollection(mode, owner, 'A', 'B', 'C');
115  const collection = await helper.ethNativeContract.collection(collectionAddress, mode, owner);115  const collection = helper.ethNativeContract.collection(collectionAddress, mode, owner);
116  const collectionHelper = helper.ethNativeContract.collectionHelpers(owner);116  const collectionHelper = helper.ethNativeContract.collectionHelpers(owner);
117  const ethEvents: any = [];117  const ethEvents: any = [];
118  collectionHelper.events.allEvents((_: any, event: any) => {118  collectionHelper.events.allEvents((_: any, event: any) => {
127    ],127    ],
128  ]).send({from: owner});128  ]).send({from: owner});
129  await helper.wait.newBlocks(1);129  await helper.wait.newBlocks(1);
130  expect(ethEvents).to.be.like([130  expect(ethEvents).to.containSubset([
131    {131    {
132      event: 'CollectionChanged',132      event: 'CollectionChanged',
133      returnValues: {133      returnValues: {
134        collectionId: collectionAddress,134        collectionId: collectionAddress,
135      },135      },
136    },136    },
137  ]);137  ]);
138  expect(subEvents).to.be.like([{method: 'PropertyPermissionSet'}]);138  expect(subEvents).to.containSubset([{method: 'PropertyPermissionSet'}]);
139  unsubscribe();139  unsubscribe();
140}140}
141141
142async function testAllowListAddressAddedAndRemoved(helper: EthUniqueHelper, mode: TCollectionMode) {142async function testAllowListAddressAddedAndRemoved(helper: EthUniqueHelper, mode: TCollectionMode) {
143  const owner = await helper.eth.createAccountWithBalance(donor);143  const owner = await helper.eth.createAccountWithBalance(donor);
144  const user = helper.ethCrossAccount.createAccount();144  const user = helper.ethCrossAccount.createAccount();
145  const {collectionAddress} = await helper.eth.createCollection(mode, owner, 'A', 'B', 'C');145  const {collectionAddress} = await helper.eth.createCollection(mode, owner, 'A', 'B', 'C');
146  const collection = await helper.ethNativeContract.collection(collectionAddress, mode, owner);146  const collection = helper.ethNativeContract.collection(collectionAddress, mode, owner);
147  const collectionHelper = helper.ethNativeContract.collectionHelpers(owner);147  const collectionHelper = helper.ethNativeContract.collectionHelpers(owner);
148  const ethEvents: any[] = [];148  const ethEvents: any[] = [];
149  collectionHelper.events.allEvents((_: any, event: any) => {149  collectionHelper.events.allEvents((_: any, event: any) => {
154  {154  {
155    await collection.methods.addToCollectionAllowListCross(user).send({from: owner});155    await collection.methods.addToCollectionAllowListCross(user).send({from: owner});
156    await helper.wait.newBlocks(1);156    await helper.wait.newBlocks(1);
157    expect(ethEvents).to.be.like([157    expect(ethEvents).to.containSubset([
158      {158      {
159        event: 'CollectionChanged',159        event: 'CollectionChanged',
160        returnValues: {160        returnValues: {
161          collectionId: collectionAddress,161          collectionId: collectionAddress,
162        },162        },
163      },163      },
164    ]);164    ]);
165    expect(subEvents).to.be.like([{method: 'AllowListAddressAdded'}]);165    expect(subEvents).to.containSubset([{method: 'AllowListAddressAdded'}]);
166    clearEvents(ethEvents, subEvents);166    clearEvents(ethEvents, subEvents);
167  }167  }
168  {168  {
169    await collection.methods.removeFromCollectionAllowListCross(user).send({from: owner});169    await collection.methods.removeFromCollectionAllowListCross(user).send({from: owner});
170    await helper.wait.newBlocks(1);170    await helper.wait.newBlocks(1);
171    expect(ethEvents.length).to.be.eq(1);
172    expect(ethEvents).to.be.like([171    expect(ethEvents).to.containSubset([
173      {172      {
174        event: 'CollectionChanged',173        event: 'CollectionChanged',
175        returnValues: {174        returnValues: {
176          collectionId: collectionAddress,175          collectionId: collectionAddress,
177        },176        },
178      },177      },
179    ]);178    ]);
180    expect(subEvents).to.be.like([{method: 'AllowListAddressRemoved'}]);179    expect(subEvents).to.containSubset([{method: 'AllowListAddressRemoved'}]);
181  }180  }
182  unsubscribe();181  unsubscribe();
183}182}
186  const owner = await helper.eth.createAccountWithBalance(donor);185  const owner = await helper.eth.createAccountWithBalance(donor);
187  const user = helper.ethCrossAccount.createAccount();186  const user = helper.ethCrossAccount.createAccount();
188  const {collectionAddress} = await helper.eth.createCollection(mode, owner, 'A', 'B', 'C');187  const {collectionAddress} = await helper.eth.createCollection(mode, owner, 'A', 'B', 'C');
189  const collection = await helper.ethNativeContract.collection(collectionAddress, mode, owner);188  const collection = helper.ethNativeContract.collection(collectionAddress, mode, owner);
190  const collectionHelper = helper.ethNativeContract.collectionHelpers(owner);189  const collectionHelper = helper.ethNativeContract.collectionHelpers(owner);
191  const ethEvents: any = [];190  const ethEvents: any = [];
192  collectionHelper.events.allEvents((_: any, event: any) => {191  collectionHelper.events.allEvents((_: any, event: any) => {
196  {195  {
197    await collection.methods.addCollectionAdminCross(user).send({from: owner});196    await collection.methods.addCollectionAdminCross(user).send({from: owner});
198    await helper.wait.newBlocks(1);197    await helper.wait.newBlocks(1);
199    expect(ethEvents).to.be.like([198    expect(ethEvents).to.containSubset([
200      {199      {
201        event: 'CollectionChanged',200        event: 'CollectionChanged',
202        returnValues: {201        returnValues: {
203          collectionId: collectionAddress,202          collectionId: collectionAddress,
204        },203        },
205      },204      },
206    ]);205    ]);
207    expect(subEvents).to.be.like([{method: 'CollectionAdminAdded'}]);206    expect(subEvents).to.containSubset([{method: 'CollectionAdminAdded'}]);
208    clearEvents(ethEvents, subEvents);207    clearEvents(ethEvents, subEvents);
209  }208  }
210  {209  {
211    await collection.methods.removeCollectionAdminCross(user).send({from: owner});210    await collection.methods.removeCollectionAdminCross(user).send({from: owner});
212    await helper.wait.newBlocks(1);211    await helper.wait.newBlocks(1);
213    expect(ethEvents).to.be.like([212    expect(ethEvents).to.containSubset([
214      {213      {
215        event: 'CollectionChanged',214        event: 'CollectionChanged',
216        returnValues: {215        returnValues: {
217          collectionId: collectionAddress,216          collectionId: collectionAddress,
218        },217        },
219      },218      },
220    ]);219    ]);
221    expect(subEvents).to.be.like([{method: 'CollectionAdminRemoved'}]);220    expect(subEvents).to.containSubset([{method: 'CollectionAdminRemoved'}]);
222  }221  }
223  unsubscribe();222  unsubscribe();
224}223}
225224
226async function testCollectionLimitSet(helper: EthUniqueHelper, mode: TCollectionMode) {225async function testCollectionLimitSet(helper: EthUniqueHelper, mode: TCollectionMode) {
227  const owner = await helper.eth.createAccountWithBalance(donor);226  const owner = await helper.eth.createAccountWithBalance(donor);
228  const {collectionAddress} = await helper.eth.createCollection(mode, owner, 'A', 'B', 'C');227  const {collectionAddress} = await helper.eth.createCollection(mode, owner, 'A', 'B', 'C');
229  const collection = await helper.ethNativeContract.collection(collectionAddress, mode, owner);228  const collection = helper.ethNativeContract.collection(collectionAddress, mode, owner);
230  const collectionHelper = helper.ethNativeContract.collectionHelpers(owner);229  const collectionHelper = helper.ethNativeContract.collectionHelpers(owner);
231  const ethEvents: any = [];230  const ethEvents: any = [];
232  collectionHelper.events.allEvents((_: any, event: any) => {231  collectionHelper.events.allEvents((_: any, event: any) => {
236  {235  {
237    await collection.methods.setCollectionLimit(CollectionLimits.OwnerCanTransfer, true, 0).send({from: owner});236    await collection.methods.setCollectionLimit(CollectionLimits.OwnerCanTransfer, true, 0).send({from: owner});
238    await helper.wait.newBlocks(1);237    await helper.wait.newBlocks(1);
239    expect(ethEvents).to.be.like([238    expect(ethEvents).to.containSubset([
240      {239      {
241        event: 'CollectionChanged',240        event: 'CollectionChanged',
242        returnValues: {241        returnValues: {
243          collectionId: collectionAddress,242          collectionId: collectionAddress,
244        },243        },
245      },244      },
246    ]);245    ]);
247    expect(subEvents).to.be.like([{method: 'CollectionLimitSet'}]);246    expect(subEvents).to.containSubset([{method: 'CollectionLimitSet'}]);
248  }247  }
249  unsubscribe();248  unsubscribe();
250}249}
253  const owner = await helper.eth.createAccountWithBalance(donor);252  const owner = await helper.eth.createAccountWithBalance(donor);
254  const newOwner = helper.ethCrossAccount.createAccount();253  const newOwner = helper.ethCrossAccount.createAccount();
255  const {collectionAddress} = await helper.eth.createCollection(mode, owner, 'A', 'B', 'C');254  const {collectionAddress} = await helper.eth.createCollection(mode, owner, 'A', 'B', 'C');
256  const collection = await helper.ethNativeContract.collection(collectionAddress, mode, owner);255  const collection = helper.ethNativeContract.collection(collectionAddress, mode, owner);
257  const collectionHelper = helper.ethNativeContract.collectionHelpers(owner);256  const collectionHelper = helper.ethNativeContract.collectionHelpers(owner);
258  const ethEvents: any = [];257  const ethEvents: any = [];
259  collectionHelper.events.allEvents((_: any, event: any) => {258  collectionHelper.events.allEvents((_: any, event: any) => {
263  {262  {
264    await collection.methods.changeCollectionOwnerCross(newOwner).send({from: owner});263    await collection.methods.changeCollectionOwnerCross(newOwner).send({from: owner});
265    await helper.wait.newBlocks(1);264    await helper.wait.newBlocks(1);
266    expect(ethEvents).to.be.like([265    expect(ethEvents).to.containSubset([
267      {266      {
268        event: 'CollectionChanged',267        event: 'CollectionChanged',
269        returnValues: {268        returnValues: {
270          collectionId: collectionAddress,269          collectionId: collectionAddress,
271        },270        },
272      },271      },
273    ]);272    ]);
274    expect(subEvents).to.be.like([{method: 'CollectionOwnerChanged'}]);273    expect(subEvents).to.containSubset([{method: 'CollectionOwnerChanged'}]);
275  }274  }
276  unsubscribe();275  unsubscribe();
277}276}
278277
279async function testCollectionPermissionSet(helper: EthUniqueHelper, mode: TCollectionMode) {278async function testCollectionPermissionSet(helper: EthUniqueHelper, mode: TCollectionMode) {
280  const owner = await helper.eth.createAccountWithBalance(donor);279  const owner = await helper.eth.createAccountWithBalance(donor);
281  const {collectionAddress} = await helper.eth.createCollection(mode, owner, 'A', 'B', 'C');280  const {collectionAddress} = await helper.eth.createCollection(mode, owner, 'A', 'B', 'C');
282  const collection = await helper.ethNativeContract.collection(collectionAddress, mode, owner);281  const collection = helper.ethNativeContract.collection(collectionAddress, mode, owner);
283  const collectionHelper = helper.ethNativeContract.collectionHelpers(owner);282  const collectionHelper = helper.ethNativeContract.collectionHelpers(owner);
284  const ethEvents: any = [];283  const ethEvents: any = [];
285  collectionHelper.events.allEvents((_: any, event: any) => {284  collectionHelper.events.allEvents((_: any, event: any) => {
289  {288  {
290    await collection.methods.setCollectionMintMode(true).send({from: owner});289    await collection.methods.setCollectionMintMode(true).send({from: owner});
291    await helper.wait.newBlocks(1);290    await helper.wait.newBlocks(1);
292    expect(ethEvents).to.be.like([291    expect(ethEvents).to.containSubset([
293      {292      {
294        event: 'CollectionChanged',293        event: 'CollectionChanged',
295        returnValues: {294        returnValues: {
296          collectionId: collectionAddress,295          collectionId: collectionAddress,
297        },296        },
298      },297      },
299    ]);298    ]);
300    expect(subEvents).to.be.like([{method: 'CollectionPermissionSet'}]);299    expect(subEvents).to.containSubset([{method: 'CollectionPermissionSet'}]);
301    clearEvents(ethEvents, subEvents);300    clearEvents(ethEvents, subEvents);
302  }301  }
303  {302  {
304    await collection.methods.setCollectionAccess(1).send({from: owner});303    await collection.methods.setCollectionAccess(1).send({from: owner});
305    await helper.wait.newBlocks(1);304    await helper.wait.newBlocks(1);
306    expect(ethEvents).to.be.like([305    expect(ethEvents).to.containSubset([
307      {306      {
308        event: 'CollectionChanged',307        event: 'CollectionChanged',
309        returnValues: {308        returnValues: {
310          collectionId: collectionAddress,309          collectionId: collectionAddress,
311        },310        },
312      },311      },
313    ]);312    ]);
314    expect(subEvents).to.be.like([{method: 'CollectionPermissionSet'}]);313    expect(subEvents).to.containSubset([{method: 'CollectionPermissionSet'}]);
315  }314  }
316  unsubscribe();315  unsubscribe();
317}316}
320  const owner = await helper.eth.createAccountWithBalance(donor);319  const owner = await helper.eth.createAccountWithBalance(donor);
321  const sponsor = await helper.ethCrossAccount.createAccountWithBalance(donor);320  const sponsor = await helper.ethCrossAccount.createAccountWithBalance(donor);
322  const {collectionAddress} = await helper.eth.createCollection(mode, owner, 'A', 'B', 'C');321  const {collectionAddress} = await helper.eth.createCollection(mode, owner, 'A', 'B', 'C');
323  const collection = await helper.ethNativeContract.collection(collectionAddress, mode, owner);322  const collection = helper.ethNativeContract.collection(collectionAddress, mode, owner);
324  const collectionHelper = helper.ethNativeContract.collectionHelpers(owner);323  const collectionHelper = helper.ethNativeContract.collectionHelpers(owner);
325  const ethEvents: any = [];324  const ethEvents: any = [];
326  collectionHelper.events.allEvents((_: any, event: any) => {325  collectionHelper.events.allEvents((_: any, event: any) => {
332  {331  {
333    await collection.methods.setCollectionSponsorCross(sponsor).send({from: owner});332    await collection.methods.setCollectionSponsorCross(sponsor).send({from: owner});
334    await helper.wait.newBlocks(1);333    await helper.wait.newBlocks(1);
335    expect(ethEvents).to.be.like([334    expect(ethEvents).to.containSubset([{
336      {
337        event: 'CollectionChanged',335      event: 'CollectionChanged',
338        returnValues: {336      returnValues: {
339          collectionId: collectionAddress,337        collectionId: collectionAddress,
340        },338      },
341      },339    }]);
342    ]);
343    expect(subEvents).to.be.like([{method: 'CollectionSponsorSet'}]);340    expect(subEvents).to.containSubset([{method: 'CollectionSponsorSet'}]);
344    clearEvents(ethEvents, subEvents);341    clearEvents(ethEvents, subEvents);
345  }342  }
346  {343  {
347    await collection.methods.confirmCollectionSponsorship().send({from: sponsor.eth});344    await collection.methods.confirmCollectionSponsorship().send({from: sponsor.eth});
348    await helper.wait.newBlocks(1);345    await helper.wait.newBlocks(1);
349    expect(ethEvents).to.be.like([346    expect(ethEvents).to.containSubset([
350      {347      {
351        event: 'CollectionChanged',348        event: 'CollectionChanged',
352        returnValues: {349        returnValues: {
353          collectionId: collectionAddress,350          collectionId: collectionAddress,
354        },351        },
355      },352      },
356    ]);353    ]);
357    expect(subEvents).to.be.like([{method: 'SponsorshipConfirmed'}]);354    expect(subEvents).to.containSubset([{method: 'SponsorshipConfirmed'}]);
358    clearEvents(ethEvents, subEvents);355    clearEvents(ethEvents, subEvents);
359  }356  }
360  {357  {
361    await collection.methods.removeCollectionSponsor().send({from: owner});358    await collection.methods.removeCollectionSponsor().send({from: owner});
362    await helper.wait.newBlocks(1);359    await helper.wait.newBlocks(1);
363    expect(ethEvents).to.be.like([360    expect(ethEvents).to.containSubset([
364      {361      {
365        event: 'CollectionChanged',362        event: 'CollectionChanged',
366        returnValues: {363        returnValues: {
367          collectionId: collectionAddress,364          collectionId: collectionAddress,
368        },365        },
369      },366      },
370    ]);367    ]);
371    expect(subEvents).to.be.like([{method: 'CollectionSponsorRemoved'}]);368    expect(subEvents).to.containSubset([{method: 'CollectionSponsorRemoved'}]);
372  }369  }
373  unsubscribe();370  unsubscribe();
374}371}
375372
376async function testTokenPropertySetAndDeleted(helper: EthUniqueHelper, mode: TCollectionMode) {373async function testTokenPropertySetAndDeleted(helper: EthUniqueHelper, mode: TCollectionMode) {
377  const owner = await helper.eth.createAccountWithBalance(donor);374  const owner = await helper.eth.createAccountWithBalance(donor);
378  const {collectionAddress} = await helper.eth.createCollection(mode, owner, 'A', 'B', 'C');375  const {collectionAddress} = await helper.eth.createCollection(mode, owner, 'A', 'B', 'C');
379  const collection = await helper.ethNativeContract.collection(collectionAddress, mode, owner);376  const collection = helper.ethNativeContract.collection(collectionAddress, mode, owner);
380  const collectionHelper = helper.ethNativeContract.collectionHelpers(owner);377  const collectionHelper = helper.ethNativeContract.collectionHelpers(owner);
381  const result = await collection.methods.mint(owner).send({from: owner});378  const result = await collection.methods.mint(owner).send({from: owner});
382  const tokenId = result.events.Transfer.returnValues.tokenId;379  const tokenId = result.events.Transfer.returnValues.tokenId;
397  {394  {
398    await collection.methods.setProperties(tokenId, [{key: 'A', value: [1,2,3]}]).send({from: owner});395    await collection.methods.setProperties(tokenId, [{key: 'A', value: [1,2,3]}]).send({from: owner});
399    await helper.wait.newBlocks(1);396    await helper.wait.newBlocks(1);
400    expect(ethEvents).to.be.like([397    expect(ethEvents).to.containSubset([
401      {398      {
402        event: 'TokenChanged',399        event: 'TokenChanged',
403        returnValues: {400        returnValues: {
404          collectionId: collectionAddress,401          collectionId: collectionAddress,
405        },402        },
406      },403      },
407    ]);404    ]);
408    expect(subEvents).to.be.like([{method: 'TokenPropertySet'}]);405    expect(subEvents).to.containSubset([{method: 'TokenPropertySet'}]);
409    clearEvents(ethEvents, subEvents);406    clearEvents(ethEvents, subEvents);
410  }407  }
411  {408  {
412    await collection.methods.deleteProperties(tokenId, ['A']).send({from: owner});409    await collection.methods.deleteProperties(tokenId, ['A']).send({from: owner});
413    await helper.wait.newBlocks(1);410    await helper.wait.newBlocks(1);
414    expect(ethEvents).to.be.like([411    expect(ethEvents).to.containSubset([
415      {412      {
416        event: 'TokenChanged',413        event: 'TokenChanged',
417        returnValues: {414        returnValues: {
418          collectionId: collectionAddress,415          collectionId: collectionAddress,
419        },416        },
420      },417      },
421    ]);418    ]);
422    expect(subEvents).to.be.like([{method: 'TokenPropertyDeleted'}]);419    expect(subEvents).to.containSubset([{method: 'TokenPropertyDeleted'}]);
423  }420  }
424  unsubscribe();421  unsubscribe();
425}422}

--- a/tests/src/eth/fungible.test.ts
+++ b/tests/src/eth/fungible.test.ts
@@ -79,23 +79,40 @@
     expect(event.returnValues.value).to.equal('100');
   });
   
+  [
+    'substrate' as const,
+    'ethereum' as const,
+  ].map(testCase => {
+    itEth(`Can perform mintCross() for ${testCase} address`, async ({helper}) => {
+      // 1. Create receiver depending on the test case:
+      const receiverEth = helper.eth.createAccount();
+      const receiverCrossEth = helper.ethCrossAccount.fromAddress(receiverEth);
+      const receiverSub = owner;
+      const receiverCrossSub = helper.ethCrossAccount.fromKeyringPair(owner);
+
+      const ethOwner = await helper.eth.createAccountWithBalance(donor);
+      const collection = await helper.ft.mintCollection(alice);
+      await collection.addAdmin(alice, {Ethereum: ethOwner});
   
-  itEth('Can perform mintCross()', async ({helper}) => {
-    const receiverCross = helper.ethCrossAccount.fromKeyringPair(owner);
-    const ethOwner = await helper.eth.createAccountWithBalance(donor);
-    const collection = await helper.ft.mintCollection(alice);
-    await collection.addAdmin(alice, {Ethereum: ethOwner});
-
-    const collectionAddress = helper.ethAddress.fromCollectionId(collection.collectionId);
-    const contract = helper.ethNativeContract.collection(collectionAddress, 'ft', ethOwner);
+      const collectionAddress = helper.ethAddress.fromCollectionId(collection.collectionId);
+      const collectionEvm = helper.ethNativeContract.collection(collectionAddress, 'ft', ethOwner);
+  
+      // 2. Mint tokens:
+      const result = await collectionEvm.methods.mintCross(testCase === 'ethereum' ? receiverCrossEth : receiverCrossSub, 100).send();
+      
+      const event = result.events.Transfer;
+      expect(event.address).to.equal(collectionAddress);
+      expect(event.returnValues.from).to.equal('0x0000000000000000000000000000000000000000');
+      expect(event.returnValues.to).to.equal(testCase === 'ethereum' ? receiverEth : helper.address.substrateToEth(receiverSub.address));
+      expect(event.returnValues.value).to.equal('100');
 
-    const result = await contract.methods.mintCross(receiverCross, 100).send();
-    
-    const event = result.events.Transfer;
-    expect(event.address).to.equal(collectionAddress);
-    expect(event.returnValues.from).to.equal('0x0000000000000000000000000000000000000000');
-    expect(event.returnValues.to).to.equal(helper.address.substrateToEth(owner.address));
-    expect(event.returnValues.value).to.equal('100');
+      // 3. Get balance depending on the test case:
+      let balance;
+      if (testCase === 'ethereum') balance = await collection.getBalance({Ethereum: receiverEth});
+      else if (testCase === 'substrate') balance = await collection.getBalance({Substrate: receiverSub.address});
+      // 3.1 Check balance:
+      expect(balance).to.eq(100n);
+    });
   });
 
   itEth('Can perform mintBulk()', async ({helper}) => {
@@ -169,6 +186,68 @@
     }
   });
 
+  itEth('Can perform approveCross()', async ({helper}) => {
+    const owner = await helper.eth.createAccountWithBalance(donor);
+    const spender = helper.eth.createAccount();
+    const spenderSub = (await helper.arrange.createAccounts([1n], donor))[0];
+    const spenderCrossEth = helper.ethCrossAccount.fromAddress(spender);
+    const spenderCrossSub = helper.ethCrossAccount.fromKeyringPair(spenderSub);
+    
+
+    const collection = await helper.ft.mintCollection(alice);
+    await collection.mint(alice, 200n, {Ethereum: owner});
+
+    const collectionAddress = helper.ethAddress.fromCollectionId(collection.collectionId);
+    const contract = helper.ethNativeContract.collection(collectionAddress, 'ft', owner);
+
+    {
+      const result = await contract.methods.approveCross(spenderCrossEth, 100).send({from: owner});
+      const event = result.events.Approval;
+      expect(event.address).to.be.equal(collectionAddress);
+      expect(event.returnValues.owner).to.be.equal(owner);
+      expect(event.returnValues.spender).to.be.equal(spender);
+      expect(event.returnValues.value).to.be.equal('100');
+    }
+
+    {
+      const allowance = await contract.methods.allowance(owner, spender).call();
+      expect(+allowance).to.equal(100);
+    }
+    
+    
+    {
+      const result = await contract.methods.approveCross(spenderCrossSub, 100).send({from: owner});
+      const event = result.events.Approval;
+      expect(event.address).to.be.equal(collectionAddress);
+      expect(event.returnValues.owner).to.be.equal(owner);
+      expect(event.returnValues.spender).to.be.equal(helper.address.substrateToEth(spenderSub.address));
+      expect(event.returnValues.value).to.be.equal('100');
+    }
+
+    {
+      const allowance = await collection.getApprovedTokens({Ethereum: owner}, {Substrate: spenderSub.address});
+      expect(allowance).to.equal(100n);
+    }
+  
+    {
+      //TO-DO expect with future allowanceCross(owner, spenderCrossEth).call()
+    }
+  });
+
+  itEth('Non-owner and non admin cannot approveCross', async ({helper}) => {
+    const nonOwner = await helper.eth.createAccountWithBalance(donor);
+    const nonOwnerCross = helper.ethCrossAccount.fromAddress(nonOwner);
+    const owner = await helper.eth.createAccountWithBalance(donor);
+    const collection = await helper.ft.mintCollection(alice, {name: 'A', description: 'B', tokenPrefix: 'C'});
+    await collection.mint(alice, 100n, {Ethereum: owner});
+
+    const collectionAddress = helper.ethAddress.fromCollectionId(collection.collectionId);
+    const collectionEvm = helper.ethNativeContract.collection(collectionAddress, 'ft', owner);
+
+    await expect(collectionEvm.methods.approveCross(nonOwnerCross, 20).call({from: nonOwner})).to.be.rejectedWith('CantApproveMoreThanOwned');
+  });
+
+
   itEth('Can perform burnFromCross()', async ({helper}) => {
     const sender = await helper.eth.createAccountWithBalance(donor, 100n);
 

--- a/tests/src/eth/nonFungible.test.ts
+++ b/tests/src/eth/nonFungible.test.ts
@@ -175,55 +175,82 @@
     // expect(tokenUri).to.be.equal(`https://offchain-service.local/token-info/${nextTokenId}`);
   });
   
-  itEth('Can perform mintCross()', async ({helper}) => {
-    const caller = await helper.eth.createAccountWithBalance(donor);
-    const receiverCross = helper.ethCrossAccount.fromKeyringPair(bob);
-    const properties = Array(5).fill(0).map((_, i) => { return {key: `key_${i}`, value: Buffer.from(`value_${i}`)}; });
-    const permissions: ITokenPropertyPermission[] = properties
-      .map(p => {
-        return {
-          key: p.key, permission: {
-            tokenOwner: true,
-            collectionAdmin: true,
-            mutable: true,
-          },
-        };
-      });
+  // TODO combine all minting tests in one place
+  [
+    'substrate' as const,
+    'ethereum' as const,
+  ].map(testCase => {
+    itEth(`Can perform mintCross() for ${testCase} address`, async ({helper}) => {
+      const collectionAdmin = await helper.eth.createAccountWithBalance(donor);
+
+      const receiverEth = helper.eth.createAccount();
+      const receiverCrossEth = helper.ethCrossAccount.fromAddress(receiverEth);
+      const receiverSub = bob;
+      const receiverCrossSub = helper.ethCrossAccount.fromKeyringPair(receiverSub);
+
+      // const receiverCross = helper.ethCrossAccount.fromKeyringPair(bob);
+      const properties = Array(5).fill(0).map((_, i) => { return {key: `key_${i}`, value: Buffer.from(`value_${i}`)}; });
+      const permissions: ITokenPropertyPermission[] = properties
+        .map(p => {
+          return {
+            key: p.key, permission: {
+              tokenOwner: false,
+              collectionAdmin: true,
+              mutable: false,
+            },
+          };
+        });
     
     
-    const collection = await helper.nft.mintCollection(minter, {
-      tokenPrefix: 'ethp',
-      tokenPropertyPermissions: permissions,
-    });
-    await collection.addAdmin(minter, {Ethereum: caller});
+      const collection = await helper.nft.mintCollection(minter, {
+        tokenPrefix: 'ethp',
+        tokenPropertyPermissions: permissions,
+      });
+      await collection.addAdmin(minter, {Ethereum: collectionAdmin});
     
-    const collectionAddress = helper.ethAddress.fromCollectionId(collection.collectionId);
-    const contract = helper.ethNativeContract.collection(collectionAddress, 'nft', caller, true);
-    let expectedTokenId = await contract.methods.nextTokenId().call();
-    let result = await contract.methods.mintCross(receiverCross, []).send();
-    let tokenId = result.events.Transfer.returnValues.tokenId;
-    expect(tokenId).to.be.equal(expectedTokenId);
+      const collectionAddress = helper.ethAddress.fromCollectionId(collection.collectionId);
+      const contract = helper.ethNativeContract.collection(collectionAddress, 'nft', collectionAdmin, true);
+      let expectedTokenId = await contract.methods.nextTokenId().call();
+      let result = await contract.methods.mintCross(testCase === 'ethereum' ? receiverCrossEth : receiverCrossSub, []).send();
+      let tokenId = result.events.Transfer.returnValues.tokenId;
+      expect(tokenId).to.be.equal(expectedTokenId);
 
-    let event = result.events.Transfer;
-    expect(event.address).to.be.equal(collectionAddress);
-    expect(event.returnValues.from).to.be.equal('0x0000000000000000000000000000000000000000');
-    expect(event.returnValues.to).to.be.equal(helper.address.substrateToEth(bob.address));
-    expect(await contract.methods.properties(tokenId, []).call()).to.be.like([]);
+      let event = result.events.Transfer;
+      expect(event.address).to.be.equal(collectionAddress);
+      expect(event.returnValues.from).to.be.equal('0x0000000000000000000000000000000000000000');
+      expect(event.returnValues.to).to.be.equal(testCase === 'ethereum' ? receiverEth : helper.address.substrateToEth(bob.address));
+      expect(await contract.methods.properties(tokenId, []).call()).to.be.like([]);
     
-    expectedTokenId = await contract.methods.nextTokenId().call();
-    result = await contract.methods.mintCross(receiverCross, properties).send();
-    event = result.events.Transfer;
-    expect(event.address).to.be.equal(collectionAddress);
-    expect(event.returnValues.from).to.be.equal('0x0000000000000000000000000000000000000000');
-    expect(event.returnValues.to).to.be.equal(helper.address.substrateToEth(bob.address));
-    expect(await contract.methods.properties(tokenId, []).call()).to.be.like([]);
+      expectedTokenId = await contract.methods.nextTokenId().call();
+      result = await contract.methods.mintCross(testCase === 'ethereum' ? receiverCrossEth : receiverCrossSub, properties).send();
+      event = result.events.Transfer;
+      expect(event.address).to.be.equal(collectionAddress);
+      expect(event.returnValues.from).to.be.equal('0x0000000000000000000000000000000000000000');
+      expect(event.returnValues.to).to.be.equal(testCase === 'ethereum' ? receiverEth : helper.address.substrateToEth(bob.address));
+      expect(await contract.methods.properties(tokenId, []).call()).to.be.like([]);
     
-    tokenId = result.events.Transfer.returnValues.tokenId;
+      tokenId = result.events.Transfer.returnValues.tokenId;
     
-    expect(tokenId).to.be.equal(expectedTokenId);
+      expect(tokenId).to.be.equal(expectedTokenId);
 
-    expect(await contract.methods.properties(tokenId, []).call()).to.be.like(properties
-      .map(p => { return helper.ethProperty.property(p.key, p.value.toString()); }));
+      expect(await contract.methods.properties(tokenId, []).call()).to.be.like(properties
+        .map(p => { return helper.ethProperty.property(p.key, p.value.toString()); }));
+      
+      expect(await helper.nft.getTokenOwner(collection.collectionId, tokenId))
+        .to.deep.eq(testCase === 'ethereum' ? {Ethereum: receiverEth.toLowerCase()} : {Substrate: receiverSub.address});
+    });
+  });
+
+  itEth('Non-owner and non admin cannot mintCross', async ({helper}) => {
+    const nonOwner = await helper.eth.createAccountWithBalance(donor);
+    const nonOwnerCross = helper.ethCrossAccount.fromAddress(nonOwner);
+
+    const collection = await helper.nft.mintCollection(minter);
+    const collectionAddress = helper.ethAddress.fromCollectionId(collection.collectionId);
+    const collectionEvm = helper.ethNativeContract.collection(collectionAddress, 'nft');
+
+    await expect(collectionEvm.methods.mintCross(nonOwnerCross, []).call({from: nonOwner}))
+      .to.be.rejectedWith('PublicMintingNotAllowed');
   });
   
   //TODO: CORE-302 add eth methods
@@ -375,6 +402,8 @@
         },
       });
     }
+
+    expect(await helper.nft.doesTokenExist(collection.collectionId, token.tokenId)).to.be.false;
   });
   
   itEth('Can perform transfer with ApprovalForAll', async ({helper}) => {
@@ -455,6 +484,7 @@
     expect(await token2.doesExist()).to.be.false;
   });
 
+  // TODO combine all approve tests in one place
   itEth('Can perform approveCross()', async ({helper}) => {
     // arrange: create accounts
     const owner = await helper.eth.createAccountWithBalance(donor, 100n);
@@ -503,6 +533,17 @@
     expect(await helper.nft.getTokenOwner(collection.collectionId, token2.tokenId)).to.deep.eq({Ethereum: receiverEth.toLowerCase()});
   });
 
+  itEth('Non-owner and non admin cannot approveCross', async ({helper}) => {
+    const nonOwner = await helper.eth.createAccountWithBalance(donor);
+    const nonOwnerCross = helper.ethCrossAccount.fromAddress(nonOwner);
+    const owner = await helper.eth.createAccountWithBalance(donor);
+    const collection = await helper.nft.mintCollection(minter, {name: 'A', description: 'B', tokenPrefix: 'C'});
+    const collectionEvm = helper.ethNativeContract.collection(helper.ethAddress.fromCollectionId(collection.collectionId), 'nft');
+    const token = await collection.mintToken(minter, {Ethereum: owner});
+
+    await expect(collectionEvm.methods.approveCross(nonOwnerCross, token.tokenId).call({from: nonOwner})).to.be.rejectedWith('CantApproveMoreThanOwned');
+  });
+
   itEth('Can reaffirm approved address', async ({helper}) => {
     const owner = await helper.eth.createAccountWithBalance(donor, 100n);
     const ownerCrossEth = helper.ethCrossAccount.fromAddress(owner);

--- a/tests/src/eth/reFungible.test.ts
+++ b/tests/src/eth/reFungible.test.ts
@@ -137,48 +137,63 @@
     expect(await contract.methods.tokenURI(tokenId).call()).to.be.equal('Test URI');
   });
   
-  itEth('Can perform mintCross()', async ({helper}) => {
-    const caller = await helper.eth.createAccountWithBalance(donor);
-    const receiverCross = helper.ethCrossAccount.fromKeyringPair(bob);
-    const properties = Array(5).fill(0).map((_, i) => { return {key: `key_${i}`, value: Buffer.from(`value_${i}`)}; });
-    const permissions: ITokenPropertyPermission[] = properties.map(p => { return {key: p.key, permission: {tokenOwner: true,
-      collectionAdmin: true,
-      mutable: true}}; });
+  [
+    'substrate' as const,
+    'ethereum' as const,
+  ].map(testCase => {
+    itEth(`Can perform mintCross() for ${testCase} address`, async ({helper}) => {
+      const collectionAdmin = await helper.eth.createAccountWithBalance(donor);
+
+      const receiverEth = helper.eth.createAccount();
+      const receiverCrossEth = helper.ethCrossAccount.fromAddress(receiverEth);
+      const receiverSub = bob;
+      const receiverCrossSub = helper.ethCrossAccount.fromKeyringPair(receiverSub);
+
+      const properties = Array(5).fill(0).map((_, i) => { return {key: `key_${i}`, value: Buffer.from(`value_${i}`)}; });
+      const permissions: ITokenPropertyPermission[] = properties.map(p => { return {key: p.key, permission: {
+        tokenOwner: false,
+        collectionAdmin: true,
+        mutable: false}};
+      });
     
     
-    const collection = await helper.rft.mintCollection(minter, {
-      tokenPrefix: 'ethp',
-      tokenPropertyPermissions: permissions,
-    });
-    await collection.addAdmin(minter, {Ethereum: caller});
+      const collection = await helper.rft.mintCollection(minter, {
+        tokenPrefix: 'ethp',
+        tokenPropertyPermissions: permissions,
+      });
+      await collection.addAdmin(minter, {Ethereum: collectionAdmin});
     
-    const collectionAddress = helper.ethAddress.fromCollectionId(collection.collectionId);
-    const contract = helper.ethNativeContract.collection(collectionAddress, 'rft', caller, true);
-    let expectedTokenId = await contract.methods.nextTokenId().call();
-    let result = await contract.methods.mintCross(receiverCross, []).send();
-    let tokenId = result.events.Transfer.returnValues.tokenId;
-    expect(tokenId).to.be.equal(expectedTokenId);
+      const collectionAddress = helper.ethAddress.fromCollectionId(collection.collectionId);
+      const contract = helper.ethNativeContract.collection(collectionAddress, 'rft', collectionAdmin, true);
+      let expectedTokenId = await contract.methods.nextTokenId().call();
+      let result = await contract.methods.mintCross(testCase === 'ethereum' ? receiverCrossEth : receiverCrossSub, []).send();
+      let tokenId = result.events.Transfer.returnValues.tokenId;
+      expect(tokenId).to.be.equal(expectedTokenId);
 
-    let event = result.events.Transfer;
-    expect(event.address).to.be.equal(collectionAddress);
-    expect(event.returnValues.from).to.be.equal('0x0000000000000000000000000000000000000000');
-    expect(event.returnValues.to).to.be.equal(helper.address.substrateToEth(bob.address));
-    expect(await contract.methods.properties(tokenId, []).call()).to.be.like([]);
+      let event = result.events.Transfer;
+      expect(event.address).to.be.equal(collectionAddress);
+      expect(event.returnValues.from).to.be.equal('0x0000000000000000000000000000000000000000');
+      expect(event.returnValues.to).to.be.equal(testCase === 'ethereum' ? receiverEth : helper.address.substrateToEth(bob.address));
+      expect(await contract.methods.properties(tokenId, []).call()).to.be.like([]);
     
-    expectedTokenId = await contract.methods.nextTokenId().call();
-    result = await contract.methods.mintCross(receiverCross, properties).send();
-    event = result.events.Transfer;
-    expect(event.address).to.be.equal(collectionAddress);
-    expect(event.returnValues.from).to.be.equal('0x0000000000000000000000000000000000000000');
-    expect(event.returnValues.to).to.be.equal(helper.address.substrateToEth(bob.address));
-    expect(await contract.methods.properties(tokenId, []).call()).to.be.like([]);
+      expectedTokenId = await contract.methods.nextTokenId().call();
+      result = await contract.methods.mintCross(testCase === 'ethereum' ? receiverCrossEth : receiverCrossSub, properties).send();
+      event = result.events.Transfer;
+      expect(event.address).to.be.equal(collectionAddress);
+      expect(event.returnValues.from).to.be.equal('0x0000000000000000000000000000000000000000');
+      expect(event.returnValues.to).to.be.equal(testCase === 'ethereum' ? receiverEth : helper.address.substrateToEth(bob.address));
+      expect(await contract.methods.properties(tokenId, []).call()).to.be.like([]);
     
-    tokenId = result.events.Transfer.returnValues.tokenId;
+      tokenId = result.events.Transfer.returnValues.tokenId;
 
-    expect(tokenId).to.be.equal(expectedTokenId);
+      expect(tokenId).to.be.equal(expectedTokenId);
     
-    expect(await contract.methods.properties(tokenId, []).call()).to.be.like(properties
-      .map(p => { return helper.ethProperty.property(p.key, p.value.toString()); }));
+      expect(await contract.methods.properties(tokenId, []).call()).to.be.like(properties
+        .map(p => { return helper.ethProperty.property(p.key, p.value.toString()); }));
+
+      expect(await helper.nft.getTokenOwner(collection.collectionId, tokenId))
+        .to.deep.eq(testCase === 'ethereum' ? {Ethereum: receiverEth.toLowerCase()} : {Substrate: receiverSub.address});
+    });
   });
 
   itEth.skip('Can perform mintBulk()', async ({helper}) => {

--- a/tests/src/eth/reFungibleToken.test.ts
+++ b/tests/src/eth/reFungibleToken.test.ts
@@ -207,7 +207,20 @@
       //TO-DO expect with future allowanceCross(owner, spenderCrossEth).call()
     }
   });
-  
+
+  itEth('Non-owner and non admin cannot approveCross', async ({helper}) => {
+    const nonOwner = await helper.eth.createAccountWithBalance(donor);
+    const nonOwnerCross = helper.ethCrossAccount.fromAddress(nonOwner);
+    const owner = await helper.eth.createAccountWithBalance(donor);
+    const collection = await helper.rft.mintCollection(alice, {name: 'A', description: 'B', tokenPrefix: 'C'});
+    const token = await collection.mintToken(alice, 100n, {Ethereum: owner});
+
+    const tokenAddress = helper.ethAddress.fromTokenId(collection.collectionId, token.tokenId);
+    const tokenEvm = helper.ethNativeContract.rftToken(tokenAddress, owner);
+
+    await expect(tokenEvm.methods.approveCross(nonOwnerCross, 20).call({from: nonOwner})).to.be.rejectedWith('CantApproveMoreThanOwned');
+  });
+
   [
     'transferFrom',
     'transferFromCross',

--- a/tests/src/eth/tokenProperties.test.ts
+++ b/tests/src/eth/tokenProperties.test.ts
@@ -37,7 +37,7 @@
     {mode: 'nft' as const, requiredPallets: []},
     {mode: 'rft' as const, requiredPallets: [Pallets.ReFungible]},
   ].map(testCase =>
-    itEth.ifWithPallets(`[${testCase.mode}] Set and get token property permissions`, testCase.requiredPallets, async({helper}) => {
+    itEth.ifWithPallets(`[${testCase.mode}] Can set all possible token property permissions`, testCase.requiredPallets, async({helper}) => {
       const owner = await helper.eth.createAccountWithBalance(donor);
       const caller = await helper.ethCrossAccount.createAccountWithBalance(donor);
       for(const [mutable,collectionAdmin, tokenOwner] of cartesian([], [false, true], [false, true], [false, true])) {
@@ -72,11 +72,11 @@
     {mode: 'nft' as const, requiredPallets: []},
     {mode: 'rft' as const, requiredPallets: [Pallets.ReFungible]},
   ].map(testCase =>
-    itEth.ifWithPallets(`[${testCase.mode}] Set and get multiple token property permissions as owner`, testCase.requiredPallets, async({helper}) => {
+    itEth.ifWithPallets(`[${testCase.mode}] Can set multiple token property permissions as owner`, testCase.requiredPallets, async({helper}) => {
       const owner = await helper.eth.createAccountWithBalance(donor);
       
       const {collectionId, collectionAddress} = await helper.eth.createCollection(testCase.mode, owner, 'A', 'B', 'C');
-      const collection = await helper.ethNativeContract.collection(collectionAddress, testCase.mode, owner);
+      const collection = helper.ethNativeContract.collection(collectionAddress, testCase.mode, owner);
 
       await collection.methods.setTokenPropertyPermissions([
         ['testKey_0', [
@@ -128,19 +128,18 @@
           [EthTokenPermissions.CollectionAdmin.toString(), false]],
         ],
       ]);
-      
     }));
 
   [
     {mode: 'nft' as const, requiredPallets: []},
     {mode: 'rft' as const, requiredPallets: [Pallets.ReFungible]},
   ].map(testCase =>
-    itEth.ifWithPallets(`[${testCase.mode}] Set and get multiple token property permissions as admin`, testCase.requiredPallets, async({helper}) => {
+    itEth.ifWithPallets(`[${testCase.mode}] Can set multiple token property permissions as admin`, testCase.requiredPallets, async({helper}) => {
       const owner = await helper.eth.createAccountWithBalance(donor);
       const caller = await helper.ethCrossAccount.createAccountWithBalance(donor);
       
       const {collectionId, collectionAddress} = await helper.eth.createCollection(testCase.mode, owner, 'A', 'B', 'C');
-      const collection = await helper.ethNativeContract.collection(collectionAddress, testCase.mode, owner);
+      const collection = helper.ethNativeContract.collection(collectionAddress, testCase.mode, owner);
       await collection.methods.addCollectionAdminCross(caller).send({from: owner});
 
       await collection.methods.setTokenPropertyPermissions([
@@ -452,12 +451,12 @@
     {mode: 'nft' as const, requiredPallets: []},
     {mode: 'rft' as const, requiredPallets: [Pallets.ReFungible]},
   ].map(testCase =>
-    itEth.ifWithPallets(`[${testCase.mode}] Cant set token property permissions as non owner or admin`, testCase.requiredPallets, async({helper}) => {
+    itEth.ifWithPallets(`[${testCase.mode}] Cannot set token property permissions as non owner or admin`, testCase.requiredPallets, async({helper}) => {
       const owner = await helper.eth.createAccountWithBalance(donor);
       const caller = await helper.eth.createAccountWithBalance(donor);
         
       const {collectionAddress} = await helper.eth.createCollection(testCase.mode, owner, 'A', 'B', 'C');
-      const collection = await helper.ethNativeContract.collection(collectionAddress, testCase.mode, owner);
+      const collection = helper.ethNativeContract.collection(collectionAddress, testCase.mode, owner);
   
       await expect(collection.methods.setTokenPropertyPermissions([
         ['testKey_0', [
@@ -472,11 +471,11 @@
     {mode: 'nft' as const, requiredPallets: []},
     {mode: 'rft' as const, requiredPallets: [Pallets.ReFungible]},
   ].map(testCase =>
-    itEth.ifWithPallets(`[${testCase.mode}] Cant set token property permissions with invalid character`, testCase.requiredPallets, async({helper}) => {
+    itEth.ifWithPallets(`[${testCase.mode}] Cannot set token property permissions with invalid character`, testCase.requiredPallets, async({helper}) => {
       const owner = await helper.eth.createAccountWithBalance(donor);
         
       const {collectionAddress} = await helper.eth.createCollection(testCase.mode, owner, 'A', 'B', 'C');
-      const collection = await helper.ethNativeContract.collection(collectionAddress, testCase.mode, owner);
+      const collection = helper.ethNativeContract.collection(collectionAddress, testCase.mode, owner);
   
       await expect(collection.methods.setTokenPropertyPermissions([
         // "Space" is invalid character
@@ -487,7 +486,73 @@
         ],
       ]).call({from: owner})).to.be.rejectedWith('InvalidCharacterInPropertyKey');  
     }));
-  
+
+  [
+    {mode: 'nft' as const, requiredPallets: []},
+    {mode: 'rft' as const, requiredPallets: [Pallets.ReFungible]},
+  ].map(testCase =>
+    itEth.ifWithPallets(`[${testCase.mode}] Can reconfigure token property permissions to stricter ones`, testCase.requiredPallets, async({helper}) => {
+      const owner = await helper.eth.createAccountWithBalance(donor);
+              
+      const {collectionAddress, collectionId} = await helper.eth.createCollection(testCase.mode, owner, 'A', 'B', 'C');
+      const collection = helper.ethNativeContract.collection(collectionAddress, testCase.mode, owner);
+        
+      // 1. Owner sets strict property-permissions:
+      await collection.methods.setTokenPropertyPermissions([
+        ['testKey', [
+          [EthTokenPermissions.Mutable, true], 
+          [EthTokenPermissions.TokenOwner, true], 
+          [EthTokenPermissions.CollectionAdmin, true]],
+        ],
+      ]).send({from: owner});
+    
+      // 2. Owner can set stricter property-permissions:
+      for(const values of [[true, true, false], [true, false, false], [false, false, false]]) {
+        await collection.methods.setTokenPropertyPermissions([
+          ['testKey', [
+            [EthTokenPermissions.Mutable, values[0]], 
+            [EthTokenPermissions.TokenOwner, values[1]], 
+            [EthTokenPermissions.CollectionAdmin, values[2]]],
+          ],
+        ]).send({from: owner});
+      }
+
+      expect(await helper[testCase.mode].getPropertyPermissions(collectionId)).to.be.deep.equal([{
+        key: 'testKey',
+        permission: {mutable: false, collectionAdmin: false, tokenOwner: false},
+      }]);
+    }));
+
+  [
+    {mode: 'nft' as const, requiredPallets: []},
+    {mode: 'rft' as const, requiredPallets: [Pallets.ReFungible]},
+  ].map(testCase =>
+    itEth.ifWithPallets(`[${testCase.mode}] Cannot reconfigure token property permissions to less strict ones`, testCase.requiredPallets, async({helper}) => {
+      const owner = await helper.eth.createAccountWithBalance(donor);
+          
+      const {collectionAddress} = await helper.eth.createCollection(testCase.mode, owner, 'A', 'B', 'C');
+      const collection = helper.ethNativeContract.collection(collectionAddress, testCase.mode, owner);
+    
+      // 1. Owner sets strict property-permissions:
+      await collection.methods.setTokenPropertyPermissions([
+        ['testKey', [
+          [EthTokenPermissions.Mutable, false], 
+          [EthTokenPermissions.TokenOwner, false], 
+          [EthTokenPermissions.CollectionAdmin, false]],
+        ],
+      ]).send({from: owner});
+
+      // 2. Owner cannot set less strict property-permissions:
+      for(const values of [[true, false, false], [false, true, false], [false, false, true]]) {
+        await expect(collection.methods.setTokenPropertyPermissions([
+          ['testKey', [
+            [EthTokenPermissions.Mutable, values[0]], 
+            [EthTokenPermissions.TokenOwner, values[1]], 
+            [EthTokenPermissions.CollectionAdmin, values[2]]],
+          ],
+        ]).call({from: owner})).to.be.rejectedWith('NoPermission');
+      }
+    }));
 });
 
 

--- a/tests/src/util/index.ts
+++ b/tests/src/util/index.ts
@@ -6,6 +6,7 @@
 import {IKeyringPair} from '@polkadot/types/types/interfaces';
 import chai from 'chai';
 import chaiAsPromised from 'chai-as-promised';
+import chaiSubset from 'chai-subset';
 import {Context} from 'mocha';
 import config from '../config';
 import {ChainHelperBase} from './playgrounds/unique';
@@ -13,6 +14,7 @@
 import {DevUniqueHelper, SilentLogger, SilentConsole, DevMoonbeamHelper, DevMoonriverHelper, DevAcalaHelper, DevKaruraHelper, DevRelayHelper, DevWestmintHelper} from './playgrounds/unique.dev';
 
 chai.use(chaiAsPromised);
+chai.use(chaiSubset);
 export const expect = chai.expect;
 
 const getTestHash = (filename: string) => {

--- a/tests/src/vesting.test.ts
+++ b/tests/src/vesting.test.ts
@@ -32,8 +32,12 @@
     // arrange
     const [sender, recepient] = await helper.arrange.createAccounts([1000n, 1n], donor);
     const currentRelayBlock = await helper.chain.getRelayBlockNumber();
-    const schedule1 = {start: currentRelayBlock + 4n, period: 4n, periodCount: 2n, perPeriod: 50n * nominal};
-    const schedule2 = {start: currentRelayBlock + 8n, period: 8n, periodCount: 2n, perPeriod: 100n * nominal};
+    const SCHEDULE_1_PERIOD = 4n; // 6 blocks one period
+    const SCHEDULE_1_START = currentRelayBlock + 6n; // Block when 1 schedule starts
+    const SCHEDULE_2_PERIOD = 8n; // 12 blocks one period
+    const SCHEDULE_2_START = currentRelayBlock + 12n; // Block when 2 schedule starts
+    const schedule1 = {start: SCHEDULE_1_START, period: SCHEDULE_1_PERIOD, periodCount: 2n, perPeriod: 50n * nominal};
+    const schedule2 = {start: SCHEDULE_2_START, period: SCHEDULE_2_PERIOD, periodCount: 2n, perPeriod: 100n * nominal};
 
     // act
     await helper.balance.vestedTransfer(sender, recepient.address, schedule1);
@@ -59,20 +63,22 @@
     expect(schedule[0]).to.deep.eq(schedule1);
     expect(schedule[1]).to.deep.eq(schedule2);
 
-    await helper.wait.forRelayBlockNumber(currentRelayBlock + 8n);
+    // Wait first part available:
+    await helper.wait.forRelayBlockNumber(SCHEDULE_1_START + SCHEDULE_1_PERIOD);
     await helper.balance.claim(recepient);
 
-    // check recepient balance after claim (50 tokens claimed):
+    // check recepient balance after claim (50 tokens claimed, 250 left):
     balanceRecepient = await helper.balance.getSubstrateFull(recepient.address);
     expect(balanceRecepient.free / nominal).to.eq(300n);
     expect(balanceRecepient.feeFrozen).to.eq(250n * nominal);
     expect(balanceRecepient.miscFrozen).to.eq(250n * nominal);
     expect(balanceRecepient.reserved).to.eq(0n);
     
-    await helper.wait.forRelayBlockNumber(currentRelayBlock + 16n);
+    // Wait first schedule ends and first part od second schedule:
+    await helper.wait.forRelayBlockNumber(SCHEDULE_2_START + SCHEDULE_2_PERIOD);
     await helper.balance.claim(recepient);
 
-    // check recepient balance after second claim (150 tokens claimed):
+    // check recepient balance after second claim (150 tokens claimed, 100 left):
     balanceRecepient = await helper.balance.getSubstrateFull(recepient.address);
     expect(balanceRecepient.free / nominal).to.eq(300n);
     expect(balanceRecepient.feeFrozen).to.eq(100n * nominal);
@@ -84,10 +90,11 @@
     expect(schedule).to.has.length(1);
     expect(schedule[0]).to.deep.eq(schedule2);
 
-    await helper.wait.forRelayBlockNumber(currentRelayBlock + 24n);
+    // Wait 2 schedule ends:
+    await helper.wait.forRelayBlockNumber(SCHEDULE_2_START + SCHEDULE_2_PERIOD * 2n);
     await helper.balance.claim(recepient);
 
-    // check recepient balance after second claim (100 tokens claimed):
+    // check recepient balance after second claim (100 tokens claimed, 0 left):
     balanceRecepient = await helper.balance.getSubstrateFull(recepient.address);
     expect(balanceRecepient.free / nominal).to.eq(300n);
     expect(balanceRecepient.feeFrozen).to.eq(0n);

--- a/tests/yarn.lock
+++ b/tests/yarn.lock
@@ -979,6 +979,13 @@
   dependencies:
     "@types/chai" "*"
 
+"@types/chai-subset@^1.3.3":
+  version "1.3.3"
+  resolved "https://registry.yarnpkg.com/@types/chai-subset/-/chai-subset-1.3.3.tgz#97893814e92abd2c534de422cb377e0e0bdaac94"
+  integrity sha512-frBecisrNGz+F4T6bcc+NLeolfiojh5FxW2klu669+8BARtyQv2C/GkNW6FUodVe4BroGMP/wER/YDGc7rEllw==
+  dependencies:
+    "@types/chai" "*"
+
 "@types/chai@*", "@types/chai@^4.3.3":
   version "4.3.4"
   resolved "https://registry.yarnpkg.com/@types/chai/-/chai-4.3.4.tgz#e913e8175db8307d78b4e8fa690408ba6b65dee4"
@@ -1569,6 +1576,11 @@
   resolved "https://registry.yarnpkg.com/chai-like/-/chai-like-1.1.1.tgz#8c558a414c34514e814d497c772547ceb7958f64"
   integrity sha512-VKa9z/SnhXhkT1zIjtPACFWSoWsqVoaz1Vg+ecrKo5DCKVlgL30F/pEyEvXPBOVwCgLZcWUleCM/C1okaKdTTA==
 
+chai-subset@^1.6.0:
+  version "1.6.0"
+  resolved "https://registry.yarnpkg.com/chai-subset/-/chai-subset-1.6.0.tgz#a5d0ca14e329a79596ed70058b6646bd6988cfe9"
+  integrity sha512-K3d+KmqdS5XKW5DWPd5sgNffL3uxdDe+6GdnJh3AYPhwnBGRY5urfvfcbRtWIvvpz+KxkL9FeBB6MZewLUNwug==
+
 chai@^4.3.6:
   version "4.3.7"
   resolved "https://registry.yarnpkg.com/chai/-/chai-4.3.7.tgz#ec63f6df01829088e8bf55fca839bcd464a8ec51"